puppet 0.25.5 → 2.6.0

data/lib/puppet/transaction/resource_harness.rb

@@ -0,0 +1,150 @@
+require 'puppet/resource/status'
+
+class Puppet::Transaction::ResourceHarness
+  extend Forwardable
+  def_delegators :@transaction, :relationship_graph
+
+  attr_reader :transaction
+
+  def allow_changes?(resource)
+    return true unless resource.purging? and resource.deleting?
+    return true unless deps = relationship_graph.dependents(resource) and ! deps.empty? and deps.detect { |d| ! d.deleting? }
+
+    deplabel = deps.collect { |r| r.ref }.join(",")
+    plurality = deps.length > 1 ? "":"s"
+    resource.warning "#{deplabel} still depend#{plurality} on me -- not purging"
+    false
+  end
+
+  def apply_changes(status, changes)
+    changes.each do |change|
+      status << change.apply
+
+      cache(change.property.resource, change.property.name, change.is) if change.auditing?
+    end
+    status.changed = true
+  end
+
+  # Used mostly for scheduling at this point.
+  def cached(resource, name)
+    Puppet::Util::Storage.cache(resource)[name]
+  end
+
+  # Used mostly for scheduling at this point.
+  def cache(resource, name, value)
+    Puppet::Util::Storage.cache(resource)[name] = value
+  end
+
+  def changes_to_perform(status, resource)
+    current = resource.retrieve_resource
+
+    cache resource, :checked, Time.now
+
+    return [] if ! allow_changes?(resource)
+
+    audited = copy_audited_parameters(resource, current)
+
+    if param = resource.parameter(:ensure)
+      return [] if absent_and_not_being_created?(current, param)
+      return [Puppet::Transaction::Change.new(param, current[:ensure])] unless ensure_is_insync?(current, param)
+      return [] if ensure_should_be_absent?(current, param)
+    end
+
+    resource.properties.reject { |p| p.name == :ensure }.reject do |param|
+      param.should.nil?
+    end.reject do |param|
+      param_is_insync?(current, param)
+    end.collect do |param|
+      change = Puppet::Transaction::Change.new(param, current[param.name])
+      change.auditing = true if audited.include?(param.name)
+      change
+    end
+  end
+
+  def copy_audited_parameters(resource, current)
+    return [] unless audit = resource[:audit]
+    audit = Array(audit).collect { |p| p.to_sym }
+    audited = []
+    audit.find_all do |param|
+      next if resource[param]
+
+      if value = cached(resource, param)
+        resource[param] = value
+        audited << param
+      else
+        resource.info "Storing newly-audited value #{current[param]} for #{param}"
+        cache(resource, param, current[param])
+      end
+    end
+
+    audited
+  end
+
+  def evaluate(resource)
+    start = Time.now
+    status = Puppet::Resource::Status.new(resource)
+
+    if changes = changes_to_perform(status, resource) and ! changes.empty?
+      status.out_of_sync = true
+      status.change_count = changes.length
+      apply_changes(status, changes)
+      if ! resource.noop?
+        cache(resource, :synced, Time.now)
+        resource.flush if resource.respond_to?(:flush)
+      end
+    end
+    return status
+  rescue => detail
+    resource.fail "Could not create resource status: #{detail}" unless status
+    puts detail.backtrace if Puppet[:trace]
+    resource.err "Could not evaluate: #{detail}"
+    status.failed = true
+    return status
+  ensure
+    (status.evaluation_time = Time.now - start) if status
+  end
+
+  def initialize(transaction)
+    @transaction = transaction
+  end
+
+  def scheduled?(status, resource)
+    return true if Puppet[:ignoreschedules]
+    return true unless schedule = schedule(resource)
+
+    # We use 'checked' here instead of 'synced' because otherwise we'll
+    # end up checking most resources most times, because they will generally
+    # have been synced a long time ago (e.g., a file only gets updated
+    # once a month on the server and its schedule is daily; the last sync time
+    # will have been a month ago, so we'd end up checking every run).
+    schedule.match?(cached(resource, :checked).to_i)
+  end
+
+  def schedule(resource)
+    unless resource.catalog
+      resource.warning "Cannot schedule without a schedule-containing catalog"
+      return nil
+    end
+
+    return nil unless name = resource[:schedule]
+    resource.catalog.resource(:schedule, name) || resource.fail("Could not find schedule #{name}")
+  end
+
+  private
+
+  def absent_and_not_being_created?(current, param)
+    current[:ensure] == :absent and param.should.nil?
+  end
+
+  def ensure_is_insync?(current, param)
+    param.insync?(current[:ensure])
+  end
+
+  def ensure_should_be_absent?(current, param)
+    param.should == :absent
+  end
+
+  def param_is_insync?(current, param)
+    param.insync?(current[param.name])
+  end
+end

data/lib/puppet/transportable.rb

@@ -1,259 +1,248 @@
 require 'puppet'
-require 'puppet/resource/reference'
 require 'yaml'
 
 module Puppet
-    # The transportable objects themselves.  Basically just a hash with some
-    # 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, :catalog
-
-        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)
-            @type = type.to_s.downcase
-            @name = name
-            @params = {}
-            @tags = []
-        end
-
-        def longname
-            return [@type,@name].join('--')
-        end
+  # The transportable objects themselves.  Basically just a hash with some
+  # 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, :catalog
+
+    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 ref
-            unless defined? @ref
-                @ref = Puppet::Resource::Reference.new(@type, @name)
-            end
-            @ref.to_s
-        end
+    def initialize(name,type)
+      @type = type.to_s.downcase
+      @name = name
+      @params = {}
+      @tags = []
+    end
 
-        def tags
-            return @tags
-        end
+    def longname
+      [@type,@name].join('--')
+    end
 
-        # Convert a defined type into a component.
-        def to_component
-            trans = TransObject.new(ref, :component)
-            @params.each { |param,value|
-                next unless Puppet::Type::Component.validattr?(param)
-                Puppet.debug "Defining %s on %s" % [param, ref]
-                trans[param] = value
-            }
-            trans.catalog = self.catalog
-            Puppet::Type::Component.create(trans)
-        end
+    def ref
+      @ref ||= Puppet::Resource.new(@type, @name)
+      @ref.to_s
+    end
 
-        def to_hash
-            @params.dup
-        end
+    def tags
+      @tags
+    end
 
-        def to_s
-            return "%s(%s) => %s" % [@type,@name,super]
-        end
+    # Convert a defined type into a component.
+    def to_component
+      trans = TransObject.new(ref, :component)
+      @params.each { |param,value|
+        next unless Puppet::Type::Component.valid_parameter?(param)
+        Puppet.debug "Defining #{param} on #{ref}"
+        trans[param] = value
+      }
+      trans.catalog = self.catalog
+      Puppet::Type::Component.create(trans)
+    end
 
-        def to_manifest
-            "%s { '%s':\n%s\n}" %
-                [self.type.to_s, self.name,
-                 @params.collect { |p, v|
-                     if v.is_a? Array
-                         "    #{p} => [\'#{v.join("','")}\']"
-                     else
-                         "    #{p} => \'#{v}\'"
-                     end
-                 }.join(",\n")
-                ]
-        end
+    def to_hash
+      @params.dup
+    end
 
-        # Create a normalized resource from our TransObject.
-        def to_resource
-            result = Puppet::Resource.new(type, name, @params.dup)
-            result.tag(*tags)
+    def to_s
+      "#{@type}(#{@name}) => #{super}"
+    end
 
-            result
-        end
+    def to_manifest
+      "%s { '%s':\n%s\n}" % [self.type.to_s, self.name,
+        @params.collect { |p, v|
+          if v.is_a? Array
+            "    #{p} => [\'#{v.join("','")}\']"
+          else
+            "    #{p} => \'#{v}\'"
+          end
+        }.join(",\n")
+        ]
+    end
 
-        def to_yaml_properties
-            instance_variables.reject { |v| %w{@ref}.include?(v) }
-        end
+    # Create a normalized resource from our TransObject.
+    def to_resource
+      result = Puppet::Resource.new(type, name, :parameters => @params.dup)
+      result.tag(*tags)
 
-        def to_ref
-            ref
-        end
+      result
+    end
 
-        def to_ral
-            to_resource.to_ral
-        end
+    def to_yaml_properties
+      instance_variables.reject { |v| %w{@ref}.include?(v) }
     end
 
-    # 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, :keyword, :top, :catalog
-
-        %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
-        }
-
-        # Recursively yield everything.
-        def delve(&block)
-            @children.each do |obj|
-                block.call(obj)
-                if obj.is_a? self.class
-                    obj.delve(&block)
-                else
-                    obj
-                end
-            end
-        end
+    def to_ref
+      ref
+    end
 
-        def each
-            @children.each { |c| yield c }
-        end
+    def to_ral
+      to_resource.to_ral
+    end
+  end
+
+  # 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, :keyword, :top, :catalog
+
+    %w{delete shift include? length empty? << []}.each { |method|
+      define_method(method) do |*args|
+        #Puppet.warning "Calling #{method} with #{args.inspect}"
+        @children.send(method, *args)
+        #Puppet.warning @params.inspect
+      end
+    }
+
+    # Recursively yield everything.
+    def delve(&block)
+      @children.each do |obj|
+        block.call(obj)
+        if obj.is_a? self.class
+          obj.delve(&block)
+        else
+          obj
+        end
+      end
+    end
 
-        # Turn our heirarchy into a flat list
-        def flatten
-            @children.collect do |obj|
-                if obj.is_a? Puppet::TransBucket
-                    obj.flatten
-                else
-                    obj
-                end
-            end.flatten
-        end
+    def each
+      @children.each { |c| yield c }
+    end
 
-        def initialize(children = [])
-            @children = children
+    # Turn our heirarchy into a flat list
+    def flatten
+      @children.collect do |obj|
+        if obj.is_a? Puppet::TransBucket
+          obj.flatten
+        else
+          obj
         end
+      end.flatten
+    end
 
-        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
-            }
-            @children += args
-        end
+    def initialize(children = [])
+      @children = children
+    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 = "#{@keyword} #{@name} {\n%s\n}"
-            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 push(*args)
+      args.each { |arg|
+        case arg
+        when Puppet::TransBucket, Puppet::TransObject
+          # nada
+        else
+          raise Puppet::DevError,
+            "TransBuckets cannot handle objects of type #{arg.class}"
+        end
+      }
+      @children += args
+    end
 
-        def to_yaml_properties
-            instance_variables
-        end
+    # Convert to a parseable manifest
+    def to_manifest
+      unless self.top
+        raise Puppet::DevError, "No keyword; cannot convert to manifest" unless @keyword
+      end
+
+      str = "#{@keyword} #{@name} {\n%s\n}"
+      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
 
-        # Create a resource graph from our structure.
-        def to_catalog(clear_on_failure = true)
-            catalog = Puppet::Resource::Catalog.new(Facter.value("hostname"))
-
-            # This should really use the 'delve' method, but this
-            # whole class is going away relatively soon, hopefully,
-            # so it's not worth it.
-            delver = proc do |obj|
-                obj.catalog = catalog
-                unless container = catalog.resource(obj.to_ref)
-                    container = obj.to_ral
-                    catalog.add_resource container
-                end
-                obj.each do |child|
-                    child.catalog = catalog
-                    unless resource = catalog.resource(child.to_ref)
-                        resource = child.to_ral
-                        catalog.add_resource resource
-                    end
-
-                    catalog.add_edge(container, resource)
-                    if child.is_a?(self.class)
-                        delver.call(child)
-                    end
-                end
-            end
-
-            begin
-                delver.call(self)
-                catalog.finalize
-            rescue => detail
-                # This is important until we lose the global resource references.
-                catalog.clear if (clear_on_failure)
-                raise
-            end
-
-            return catalog
-        end
+    def to_yaml_properties
+      instance_variables
+    end
 
-        def to_ref
-            unless defined? @ref
-                if self.type and self.name
-                    @ref = Puppet::Resource::Reference.new(self.type, self.name)
-                elsif self.type and ! self.name # This is old-school node types
-                    @ref = Puppet::Resource::Reference.new("node", self.type)
-                elsif ! self.type and self.name
-                    @ref = Puppet::Resource::Reference.new("component", self.name)
-                else
-                    @ref = nil
-                end
-            end
-            @ref.to_s if @ref
-        end
+    # Create a resource graph from our structure.
+    def to_catalog(clear_on_failure = true)
+      catalog = Puppet::Resource::Catalog.new(Facter.value("hostname"))
+
+      # This should really use the 'delve' method, but this
+      # whole class is going away relatively soon, hopefully,
+      # so it's not worth it.
+      delver = proc do |obj|
+        obj.catalog = catalog
+        unless container = catalog.resource(obj.to_ref)
+          container = obj.to_ral
+          catalog.add_resource container
+        end
+        obj.each do |child|
+          child.catalog = catalog
+          unless resource = catalog.resource(child.to_ref)
+            resource = child.to_ral
+            catalog.add_resource resource
+          end
+
+          catalog.add_edge(container, resource)
+          delver.call(child) if child.is_a?(self.class)
+        end
+      end
+
+      begin
+        delver.call(self)
+        catalog.finalize
+      rescue => detail
+        # This is important until we lose the global resource references.
+        catalog.clear if (clear_on_failure)
+        raise
+      end
+
+      catalog
+    end
 
-        def to_ral
-            to_resource.to_ral
-        end
+    def to_ref
+      unless defined?(@ref)
+        if self.type and self.name
+          @ref = Puppet::Resource.new(self.type, self.name)
+        elsif self.type and ! self.name # This is old-school node types
+          @ref = Puppet::Resource.new("node", self.type)
+        elsif ! self.type and self.name
+          @ref = Puppet::Resource.new("component", self.name)
+        else
+          @ref = nil
+        end
+      end
+      @ref.to_s if @ref
+    end
 
-        # Create a normalized resource from our TransObject.
-        def to_resource
-            params = defined?(@parameters) ? @parameters.dup : {}
-            Puppet::Resource.new(type, name, params)
-        end
+    def to_ral
+      to_resource.to_ral
+    end
 
-        def param(param,value)
-            unless defined? @parameters
-                @parameters = {}
-            end
-            @parameters[param] = value
-        end
+    # Create a normalized resource from our TransObject.
+    def to_resource
+      params = defined?(@parameters) ? @parameters.dup : {}
+      Puppet::Resource.new(type, name, :parameters => params)
+    end
 
+    def param(param,value)
+      @parameters ||= {}
+      @parameters[param] = value
     end
+
+  end
 end