puppet 0.9.2

data/lib/puppet/statechange.rb

@@ -0,0 +1,150 @@
+# the class responsible for actually doing any work
+
+# enables no-op and logging/rollback
+
+module Puppet
+	class StateChange
+        attr_accessor :is, :should, :type, :path, :state, :transaction, :changed
+
+		#---------------------------------------------------------------
+        def initialize(state)
+            @state = state
+            @path = [state.path,"change"].flatten
+            @is = state.is
+
+            if state.is == state.should
+                raise Puppet::Error.new(
+                    "Tried to create a change for in-sync state %s" % state.name
+                )
+            end
+            @should = state.should
+
+            @changed = false
+        end
+		#---------------------------------------------------------------
+
+		#---------------------------------------------------------------
+        def go
+            if @state.is == @state.should
+                @state.info "already in sync"
+                return nil
+            end
+
+            if @state.noop
+                @state.log "is %s, should be %s" %
+                    [state.is_to_s, state.should_to_s]
+                #@state.debug "%s is noop" % @state
+                return nil
+            end
+
+            begin
+                events = @state.sync
+                if events.nil?
+                    return nil
+                end
+
+                if events.is_a?(Array)
+                    if events.empty?
+                        return nil
+                    end
+                else
+                    events = [events]
+                end
+                
+                return events.collect { |event|
+                    # default to a simple event type
+                    if ! event.is_a?(Symbol)
+                        @state.warning("State '%s' returned invalid event '%s'; resetting to default" %
+                            [@state.class,event])
+
+                        event = @state.parent.class.name.id2name + "_changed"
+                    end
+
+                    # i should maybe include object type, but the event type
+                    # should basically point to that, right?
+                        #:state => @state,
+                        #:object => @state.parent,
+                    @state.log @state.change_to_s
+                    Puppet::Event.new(
+                        :event => event,
+                        :change => self,
+                        :transaction => @transaction,
+                        :source => @state.parent,
+                        :message => self.to_s
+                    )
+                }
+            rescue => detail
+                #@state.err "%s failed: %s" % [self.to_s,detail]
+                raise
+                # there should be a way to ask the state what type of event
+                # it would have generated, but...
+                pname = @state.parent.class.name.id2name
+                #if pname.is_a?(Symbol)
+                #    pname = pname.id2name
+                #end
+                    #:state => @state,
+                @state.log "Failed: " + @state.change_to_s
+                return Puppet::Event.new(
+                    :event => pname + "_failed",
+                    :change => self,
+                    :source => @state.parent,
+                    :transaction => @transaction,
+                    :message => "Failed: " + self.to_s
+                )
+            end
+        end
+		#---------------------------------------------------------------
+
+		#---------------------------------------------------------------
+        def forward
+            #@state.debug "moving change forward"
+
+            unless defined? @transaction
+                raise Puppet::Error,
+                    "StateChange '%s' tried to be executed outside of transaction" %
+                    self
+            end
+
+            return self.go
+        end
+		#---------------------------------------------------------------
+
+		#---------------------------------------------------------------
+        def backward
+            @state.should = @is
+            @state.retrieve
+
+            unless defined? @transaction
+                raise Puppet::Error,
+                    "StateChange '%s' tried to be executed outside of transaction" %
+                    self
+            end
+            unless @state.insync?
+                @state.info "Backing %s" % self
+                return self.go
+            else
+                @state.debug "rollback is already in sync: %s vs. %s" %
+                    [@state.is.inspect, @state.should.inspect]
+                return nil
+            end
+
+            #raise "Moving statechanges backward is currently unsupported"
+            #@type.change(@path,@should,@is)
+        end
+		#---------------------------------------------------------------
+        
+		#---------------------------------------------------------------
+        def noop
+            return @state.noop
+        end
+		#---------------------------------------------------------------
+
+        def to_s
+            return "change %s.%s(%s)" %
+                [@transaction.object_id, self.object_id, @state.change_to_s]
+            #return "change %s.%s" % [@transaction.object_id, self.object_id]
+        end
+	end
+end
+
+# $Id: statechange.rb 740 2005-11-01 20:22:19Z luke $

data/lib/puppet/storage.rb

@@ -0,0 +1,95 @@
+module Puppet
+    # a class for storing state
+	class Storage
+		include Singleton
+		
+		def initialize
+			self.class.load
+		end
+
+        def self.clear
+            @@state = nil
+            Storage.init
+        end
+
+        def self.init
+            Puppet.debug "Initializing Storage"
+            @@state = Hash.new { |hash,key|
+                hash[key] = Hash.new(nil)
+            }
+            @@splitchar = "\t"
+        end
+
+        self.init
+
+		def self.load
+            if Puppet[:checksumfile].nil?
+                raise Puppet::DevError, "Somehow the statefile is nil"
+            end
+
+			unless File.exists?(Puppet[:checksumfile])
+                Puppet.info "Statefile %s does not exist" % Puppet[:checksumfile]
+                return
+            end
+            begin
+            #Puppet.debug "Loading statefile %s" % Puppet[:checksumfile]
+			File.open(Puppet[:checksumfile]) { |file|
+				file.each { |line|
+					myclass, key, value = line.split(@@splitchar)
+
+                    begin
+                        @@state[eval(myclass)][key] = Marshal::load(value)
+                    rescue => detail
+                        raise Puppet::Error,
+                            "Failed to load value for %s::%s => %s" % [
+                                myclass,key,detail
+                            ], caller
+                    end
+				}
+			}
+            rescue => detail
+                Puppet.err "Could not read %s" % Puppet[:checksumfile]
+            end
+
+            #Puppet.debug "Loaded state is %s" % @@state.inspect
+		end
+
+		def self.state(myclass)
+            unless myclass.is_a? Class
+                myclass = myclass.class
+            end
+            result = @@state[myclass]
+            return result
+		end
+
+		def self.store
+            unless FileTest.directory?(File.dirname(Puppet[:checksumfile]))
+                begin
+                    Puppet.recmkdir(File.dirname(Puppet[:checksumfile]))
+                    Puppet.info "Creating state directory %s" %
+                        File.dirname(Puppet[:checksumfile])
+                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]
+            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
+end
+
+# $Id: storage.rb 742 2005-11-16 17:12:11Z luke $

data/lib/puppet/transaction.rb

@@ -0,0 +1,179 @@
+# 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
+
+    #---------------------------------------------------------------
+    # 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
+    # so, when looking for subscribers, we need to first see if the object
+    # that actually changed had any direct subscribers
+    # 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
+
+        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
+                    Puppet.err("%s failed: %s" % [change.to_s,detail])
+                    if Puppet[:debug] and detail.respond_to?(:stack)
+                        puts detail.stack
+                    end
+                    next
+                    # FIXME this should support using onerror to determine
+                    # behaviour; or more likely, the client calling us
+                    # should do so
+                end
+
+                unless events.nil? or (events.is_a?(Array) and events.empty?)
+                    change.changed = true
+                end
+                events
+            else
+                raise Puppet::DevError,
+                    "Transactions cannot handle objects of type %s" % child.class
+            end
+        }.flatten.reject { |event|
+            event.nil?
+        }
+
+        #@triggerevents = []
+        events.each { |event|
+            object = event.source
+            #Puppet::Event::Subscriptions.propagate(object, event, self)
+            object.propagate(event, self)
+        }
+
+        #events += @triggerevents
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # this should only be called by a Puppet::Container object now
+    # and it should only receive an array
+    def initialize(objects)
+        @objects = objects
+        @toplevel = false
+
+        @triggered = Hash.new { |hash, key|
+            hash[key] = Hash.new(0)
+        }
+
+        # of course, this won't work on the second run
+        unless defined? @@failures
+            @toplevel = true
+            self.class.init
+        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|
+            # these children are all Puppet::Type instances
+            # not all of the children will return a change, and Containers
+            # return transactions
+            child.evaluate
+        }.flatten.reject { |child|
+            child.nil? # remove empties
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def rollback
+        events = @changes.reverse.collect { |change|
+            if change.is_a?(Puppet::StateChange)
+                # skip changes that were never actually run
+                unless change.changed
+                    Puppet.debug "%s was not changed" % change.to_s
+                    next
+                end
+                #change.transaction = self
+                begin
+                    change.backward
+                    #@@changed.push change.state.parent
+                rescue => detail
+                    Puppet.err("%s rollback failed: %s" % [change,detail])
+                    next
+                    # at this point, we would normally do error handling
+                    # but i haven't decided what to do for that yet
+                    # so just record that a sync failed for a given object
+                    #@@failures[change.state.parent] += 1
+                    # this still could get hairy; what if file contents changed,
+                    # but a chmod failed?  how would i handle that error? dern
+                end
+            elsif change.is_a?(Puppet::Transaction)
+                raise Puppet::DevError, "Got a sub-transaction"
+                # yay, recursion
+                change.rollback
+            else
+                raise Puppe::DevError,
+                    "Transactions cannot handle objects of type %s" % child.class
+            end
+        }.flatten.reject { |e| e.nil? }
+
+        #@triggerevents = []
+        events.each { |event|
+            object = event.source
+            object.propagate(event, self)
+        }
+
+        #events += @triggerevents
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    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
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def triggered?(object, method)
+        Puppet.notice "Looking for triggered %s" % method
+        @triggered[object][method]
+    end
+    #---------------------------------------------------------------
+end
+end
+#---------------------------------------------------------------
+
+# $Id: transaction.rb 740 2005-11-01 20:22:19Z luke $

data/lib/puppet/transportable.rb

@@ -0,0 +1,151 @@
+require 'puppet'
+
+module Puppet
+    # The transportable objects themselves.  Basically just a hash with some
+    # metadata and a few extra methods.
+    class TransObject < Hash
+        attr_accessor :type, :name, :file, :line
+
+        attr_writer :tags
+
+        def initialize(name,type)
+            self[:name] = name
+            @type = type
+            @name = name
+            #self.class.add(self)
+        end
+
+        def longname
+            return [self.type,self[:name]].join('--')
+        end
+
+        def tags
+            return @tags
+        end
+
+        def to_s
+            return "%s(%s) => %s" % [@type,self[:name],super]
+        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)
+                    return nil
+                end
+                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 parent
+                parent.push retobj
+            end
+
+            return retobj
+        end
+    end
+    #------------------------------------------------------------
+
+    #------------------------------------------------------------
+    # just a linear container for objects
+    class TransBucket < Array
+        attr_accessor :name, :type, :file, :line
+
+        def push(*args)
+            args.each { |arg|
+                case arg
+                when Puppet::TransBucket, Puppet::TransObject
+                    # nada
+                else
+                    raise Puppet::DevError,
+                        "TransBuckets cannot handle objects of type %s" %
+                            arg.class
+                end
+            }
+            super
+        end
+
+        def to_type(parent = nil)
+            # this container will contain the equivalent of all objects at
+            # this level
+            #container = Puppet::Component.new(:name => @name, :type => @type)
+            unless defined? @name
+                raise Puppet::DevError, "TransBuckets must have names"
+            end
+            unless defined? @type
+                Puppet.debug "TransBucket '%s' has no type" % @name
+            end
+            hash = {
+                :name => @name,
+                :type => @type
+            }
+            if defined? @parameters
+                @parameters.each { |param,value|
+                    Puppet.debug "Defining %s on %s of type %s" %
+                        [param,@name,@type]
+                    hash[param] = value
+                }
+            else
+                Puppet.debug "%s[%s] has no parameters" % [@type, @name]
+            end
+
+            if parent
+                hash[:parent] = parent
+            end
+            container = Puppet::Type::Component.create(hash)
+
+            if parent
+                parent.push container
+            end
+
+            # unless we successfully created the container, return an error
+            unless container
+                Puppet.warning "Got no container back"
+                return nil
+            end
+
+            self.each { |child|
+                # the fact that we descend here means that we are
+                # always going to execute depth-first
+                # which is _probably_ a good thing, but one never knows...
+                unless  child.is_a?(Puppet::TransBucket) or
+                        child.is_a?(Puppet::TransObject)
+                    raise Puppet::DevError,
+                        "TransBucket#to_type cannot handle objects of type %s" %
+                            child.class
+                end
+
+                # 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
+                end
+            }
+
+            # at this point, no objects at are level are still Transportable
+            # objects
+            return container
+        end
+
+        def param(param,value)
+            unless defined? @parameters
+                @parameters = {}
+            end
+            @parameters[param] = value
+        end
+
+    end
+    #------------------------------------------------------------
+end
+
+# $Id: transportable.rb 740 2005-11-01 20:22:19Z luke $