puppet 0.25.5 → 2.6.0

data/lib/puppet/transaction/change.rb

@@ -4,89 +4,84 @@ require 'puppet/transaction/event'
 # Handle all of the work around performing an actual change,
 # including calling 'sync' on the properties and producing events.
 class Puppet::Transaction::Change
-    attr_accessor :is, :should, :path, :property, :changed, :proxy
-
-    # Switch the goals of the property, thus running the change in reverse.
-    def backward
-        @is, @should = @should, @is
-        @property.should = @should
-
-        @property.info "Reversing %s" % self
-        return self.go
-    end
-
-    def changed?
-        self.changed
-    end
-
-    # Create our event object.
-    def event(name)
-        # default to a simple event type
-        unless name.is_a?(Symbol)
-            @property.warning("Property '%s' returned invalid event '%s'; resetting to default" %
-                [@property.class, name])
-
-            name = @property.event(should)
-        end
-
-        Puppet::Transaction::Event.new(name, self.resource)
-    end
-
-    def initialize(property, currentvalue)
-        @property = property
-        @path = [property.path,"change"].flatten
-        @is = currentvalue
-
-        @should = property.should
-
-        @changed = false
-    end
-
-    # Perform the actual change.  This method can go either forward or
-    # backward, and produces an event.
-    def go
-        if self.noop?
-            @property.log "is %s, should be %s (noop)" % [property.is_to_s(@is), property.should_to_s(@should)]
-            return [event(:noop)]
-        end
-
-        # The transaction catches any exceptions here.
-        events = @property.sync
-        if events.nil?
-            events = [(@property.name.to_s + "_changed").to_sym]
-        elsif events.is_a?(Array)
-            if events.empty?
-                events = [(@property.name.to_s + "_changed").to_sym]
-            end
-        else
-            events = [events]
-        end
-
-        return events.collect { |name|
-            @report = @property.log(@property.change_to_s(@is, @should))
-            event(name)
-        }
-    end
-
-    def forward
-        return self.go
-    end
-
-    # Is our property noop?  This is used for generating special events.
-    def noop?
-        return @property.noop
-    end
-
-    # The resource that generated this change.  This is used for handling events,
-    # and the proxy resource is used for generated resources, since we can't
-    # send an event to a resource we don't have a direct relationship.  If we
-    # have a proxy resource, then the events will be considered to be from
-    # that resource, rather than us, so the graph resolution will still work.
-    def resource
-        self.proxy || @property.resource
-    end
-
-    def to_s
-        return "change %s" % @property.change_to_s(@is, @should)
-    end
+  attr_accessor :is, :should, :property, :proxy, :auditing
+
+  def auditing?
+    auditing
+  end
+
+  # Create our event object.
+  def event
+    result = property.event
+    result.previous_value = is
+    result.desired_value = should
+    result
+  end
+
+  def initialize(property, currentvalue)
+    @property = property
+    @is = currentvalue
+
+    @should = property.should
+
+    @changed = false
+  end
+
+  def apply
+    return audit_event if auditing?
+    return noop_event if noop?
+
+    property.sync
+
+    result = event
+    result.message = property.change_to_s(is, should)
+    result.status = "success"
+    result.send_log
+    result
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    result = event
+    result.status = "failure"
+
+    result.message = "change from #{property.is_to_s(is)} to #{property.should_to_s(should)} failed: #{detail}"
+    result.send_log
+    result
+  end
+
+  # Is our property noop?  This is used for generating special events.
+  def noop?
+    @property.noop
+  end
+
+  # The resource that generated this change.  This is used for handling events,
+  # and the proxy resource is used for generated resources, since we can't
+  # send an event to a resource we don't have a direct relationship with.  If we
+  # have a proxy resource, then the events will be considered to be from
+  # that resource, rather than us, so the graph resolution will still work.
+  def resource
+    self.proxy || @property.resource
+  end
+
+  def to_s
+    "change #{@property.change_to_s(@is, @should)}"
+  end
+
+  private
+
+  def audit_event
+    # This needs to store the appropriate value, and then produce a new event
+    result = event
+    result.message = "audit change: previously recorded value #{property.should_to_s(should)} has been changed to #{property.is_to_s(is)}"
+    result.status = "audit"
+    result.send_log
+    result
+  end
+
+  def noop_event
+    result = event
+    result.message = "is #{property.is_to_s(is)}, should be #{property.should_to_s(should)} (noop)"
+    result.status = "noop"
+    result.send_log
+    result
+  end
 end

data/lib/puppet/transaction/event.rb

@@ -1,21 +1,61 @@
-require 'puppet'
-require 'puppet/util/methodhelper'
-require 'puppet/util/errors'
+require 'puppet/transaction'
+require 'puppet/util/tagging'
+require 'puppet/util/logging'
 
-# events are transient packets of information; they result in one or more (or none)
-# subscriptions getting triggered, and then they get cleared
-# eventually, these will be passed on to some central event system
+# A simple struct for storing what happens on the system.
 class Puppet::Transaction::Event
-    include Puppet::Util::MethodHelper
-    include Puppet::Util::Errors
+  include Puppet::Util::Tagging
+  include Puppet::Util::Logging
 
-    attr_reader :name, :source
+  ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :status, :message, :node, :version, :file, :line, :source_description]
+  attr_accessor *ATTRIBUTES
+  attr_writer :tags
+  attr_accessor :time
+  attr_reader :default_log_level
 
-    def initialize(name, source)
-        @name, @source = name, source
-    end
+  EVENT_STATUSES = %w{noop success failure audit}
+
+  def initialize(*args)
+    options = args.last.is_a?(Hash) ? args.pop : ATTRIBUTES.inject({}) { |hash, attr| hash[attr] = args.pop; hash }
+    options.each { |attr, value| send(attr.to_s + "=", value) unless value.nil? }
+
+    @time = Time.now
+  end
 
-    def to_s
-        source.to_s + " -> " + name.to_s
+  def property=(prop)
+    @property = prop.to_s
+  end
+
+  def resource=(res)
+    if res.respond_to?(:[]) and level = res[:loglevel]
+      @default_log_level = level
     end
+    @resource = res.to_s
+  end
+
+  def send_log
+    super(log_level, message)
+  end
+
+  def status=(value)
+    raise ArgumentError, "Event status can only be #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
+    @status = value
+  end
+
+  def to_s
+    message
+  end
+
+  private
+
+  # If it's a failure, use 'err', else use either the resource's log level (if available)
+  # or 'notice'.
+  def log_level
+    status == "failure" ? :err : (@default_log_level || :notice)
+  end
+
+  # Used by the Logging module
+  def log_source
+    source_description || property || resource
+  end
 end

data/lib/puppet/transaction/event_manager.rb

@@ -0,0 +1,99 @@
+require 'puppet/transaction'
+
+class Puppet::Transaction::EventManager
+  attr_reader :transaction, :events
+
+  def initialize(transaction)
+    @transaction = transaction
+    @event_queues = {}
+    @events = []
+  end
+
+  def relationship_graph
+    transaction.relationship_graph
+  end
+
+  # Respond to any queued events for this resource.
+  def process_events(resource)
+    restarted = false
+    queued_events(resource) do |callback, events|
+      r = process_callback(resource, callback, events)
+      restarted ||= r
+    end
+
+    if restarted
+      queue_events(resource, [resource.event(:name => :restarted, :status => "success")])
+
+      transaction.resource_status(resource).restarted = true
+    end
+  end
+
+  # Queue events for other resources to respond to.  All of these events have
+  # to be from the same resource.
+  def queue_events(resource, events)
+    @events += events
+
+    # Do some basic normalization so we're not doing so many
+    # graph queries for large sets of events.
+    events.inject({}) do |collection, event|
+      collection[event.name] ||= []
+      collection[event.name] << event
+      collection
+    end.collect do |name, list|
+      # It doesn't matter which event we use - they all have the same source
+      # and name here.
+      event = list[0]
+
+      # Collect the targets of any subscriptions to those events.  We pass
+      # the parent resource in so it will override the source in the events,
+      # since eval_generated children can't have direct relationships.
+      relationship_graph.matching_edges(event, resource).each do |edge|
+        next unless method = edge.callback
+        next unless edge.target.respond_to?(method)
+
+        queue_events_for_resource(resource, edge.target, method, list)
+      end
+
+      queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and ! resource.deleting?
+    end
+  end
+
+  def queue_events_for_resource(source, target, callback, events)
+    source.info "Scheduling #{callback} of #{target}"
+
+    @event_queues[target] ||= {}
+    @event_queues[target][callback] ||= []
+    @event_queues[target][callback] += events
+  end
+
+  def queued_events(resource)
+    return unless callbacks = @event_queues[resource]
+    callbacks.each do |callback, events|
+      yield callback, events
+    end
+  end
+
+  private
+
+  def process_callback(resource, callback, events)
+    process_noop_events(resource, callback, events) and return false unless events.detect { |e| e.status != "noop" }
+    resource.send(callback)
+
+    resource.notice "Triggered '#{callback}' from #{events.length} events"
+    return true
+  rescue => detail
+    resource.err "Failed to call #{callback}: #{detail}"
+
+    transaction.resource_status(resource).failed_to_restart = true
+    puts detail.backtrace if Puppet[:trace]
+    return false
+  end
+
+  def process_noop_events(resource, callback, events)
+    resource.notice "Would have triggered '#{callback}' from #{events.length} events"
+
+    # And then add an event for it.
+    queue_events(resource, [resource.event(:status => "noop", :name => :noop_restart)])
+    true # so the 'and if' works
+  end
+end

data/lib/puppet/transaction/report.rb

@@ -6,82 +6,144 @@ require 'puppet/indirector'
 # change produces, and Metrics are all of the numerical data involved
 # in the transaction.
 class Puppet::Transaction::Report
-    extend Puppet::Indirector
+  extend Puppet::Indirector
 
-    indirects :report, :terminus_class => :processor
+  indirects :report, :terminus_class => :processor
 
-    attr_accessor :logs, :metrics, :time, :host
+  attr_reader :resource_statuses, :logs, :metrics, :host, :time
 
-    # This is necessary since Marshall doesn't know how to
-    # dump hash with default proc (see below @records)
-    def self.default_format
-        :yaml
-    end
+  # This is necessary since Marshall doesn't know how to
+  # dump hash with default proc (see below @records)
+  def self.default_format
+    :yaml
+  end
 
-    def <<(msg)
-        @logs << msg
-        return self
-    end
+  def <<(msg)
+    @logs << msg
+    self
+  end
 
-    def initialize
-        @metrics = {}
-        @logs = []
+  def add_times(name, value)
+    @external_times[name] = value
+  end
 
-        @records = Hash.new do |hash, key|
-            hash[key] = []
-        end
+  def add_metric(name, hash)
+    metric = Puppet::Util::Metric.new(name)
 
-        @host = Puppet[:certname]
+    hash.each do |name, value|
+      metric.newvalue(name, value)
     end
 
-    def name
-        host
+    @metrics[metric.name] = metric
+    metric
+  end
+
+  def add_resource_status(status)
+    @resource_statuses[status.resource] = status
+  end
+
+  def calculate_metrics
+    calculate_resource_metrics
+    calculate_time_metrics
+    calculate_change_metrics
+    calculate_event_metrics
+  end
+
+  def initialize
+    @metrics = {}
+    @logs = []
+    @resource_statuses = {}
+    @external_times ||= {}
+    @host = Puppet[:certname]
+    @time = Time.now
+  end
+
+  def name
+    host
+  end
+
+  # Provide a summary of this report.
+  def summary
+    ret = ""
+
+    @metrics.sort { |a,b| a[1].label <=> b[1].label }.each do |name, metric|
+      ret += "#{metric.label}:\n"
+      metric.values.sort { |a,b|
+        # sort by label
+        if a[0] == :total
+          1
+        elsif b[0] == :total
+          -1
+        else
+          a[1] <=> b[1]
+        end
+      }.each do |name, label, value|
+        next if value == 0
+        value = "%0.2f" % value if value.is_a?(Float)
+        ret += "   %15s %s\n" % [label + ":", value]
+      end
+    end
+    ret
+  end
+
+  # Based on the contents of this report's metrics, compute a single number
+  # that represents the report. The resulting number is a bitmask where
+  # individual bits represent the presence of different metrics.
+  def exit_status
+    status = 0
+    status |= 2 if @metrics["changes"][:total] > 0
+    status |= 4 if @metrics["resources"][:failed] > 0
+    status
+  end
+
+  private
+
+  def calculate_change_metrics
+    metrics = Hash.new(0)
+    resource_statuses.each do |name, status|
+      metrics[:total] += status.change_count if status.change_count
     end
 
-    # Create a new metric.
-    def newmetric(name, hash)
-        metric = Puppet::Util::Metric.new(name)
-
-        hash.each do |name, value|
-            metric.newvalue(name, value)
-        end
+    add_metric(:changes, metrics)
+  end
 
-        @metrics[metric.name] = metric
+  def calculate_event_metrics
+    metrics = Hash.new(0)
+    resource_statuses.each do |name, status|
+      metrics[:total] += status.events.length
+      status.events.each do |event|
+        metrics[event.status] += 1
+      end
     end
 
-    # Add a new log message.
-    def newlog(msg)
-        @logs << msg
+    add_metric(:events, metrics)
+  end
+
+  def calculate_resource_metrics
+    metrics = Hash.new(0)
+    metrics[:total] = resource_statuses.length
+
+    resource_statuses.each do |name, status|
+
+      Puppet::Resource::Status::STATES.each do |state|
+        metrics[state] += 1 if status.send(state)
+      end
     end
 
-    def record(metric, object)
-        @records[metric] << object
+    add_metric(:resources, metrics)
+  end
+
+  def calculate_time_metrics
+    metrics = Hash.new(0)
+    resource_statuses.each do |name, status|
+      type = Puppet::Resource.new(name).type
+      metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
     end
 
-    # Provide a summary of this report.
-    def summary
-        ret = ""
-
-        @metrics.sort { |a,b| a[1].label <=> b[1].label }.each do |name, metric|
-            ret += "%s:\n" % metric.label
-            metric.values.sort { |a,b|
-                # sort by label
-                if a[0] == :total
-                    1
-                elsif b[0] == :total
-                    -1
-                else
-                    a[1] <=> b[1]
-                end
-            }.each do |name, label, value|
-                next if value == 0
-                if value.is_a?(Float)
-                    value = "%0.2f" % value
-                end
-                ret += "   %15s %s\n" % [label + ":", value]
-            end
-        end
-        return ret
+    @external_times.each do |name, value|
+      metrics[name.to_s.downcase] = value
     end
-end
 
+    add_metric(:time, metrics)
+  end
+end