puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/transaction/event.rb

@@ -0,0 +1,66 @@
+require 'puppet/transaction'
+require 'puppet/util/tagging'
+require 'puppet/util/logging'
+
+# A simple struct for storing what happens on the system.
+class Puppet::Transaction::Event
+  include Puppet::Util::Tagging
+  include Puppet::Util::Logging
+
+  ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited]
+  YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}
+  attr_accessor *ATTRIBUTES
+  attr_writer :tags
+  attr_accessor :time
+  attr_reader :default_log_level
+
+  EVENT_STATUSES = %w{noop success failure audit}
+
+  def initialize(options = {})
+    @audited = false
+    options.each { |attr, value| send(attr.to_s + "=", value) }
+
+    @time = Time.now
+  end
+
+  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
+
+  def to_yaml_properties
+    YAML_ATTRIBUTES & instance_variables
+  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/vendor/puppet/transaction/event_manager.rb

@@ -0,0 +1,115 @@
+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.
+      received = (event.name != :restarted)
+      relationship_graph.matching_edges(event, resource).each do |edge|
+        received ||= true unless edge.target.is_a?(Puppet::Type.type(:whit))
+        next unless method = edge.callback
+        next unless edge.target.respond_to?(method)
+
+        queue_events_for_resource(resource, edge.target, method, list)
+      end
+      @events << event if received
+
+      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)
+    whit = Puppet::Type.type(:whit)
+
+    # The message that a resource is refreshing the completed-whit for its own class
+    # is extremely counter-intuitive. Basically everything else is easy to understand,
+    # if you suppress the whit-lookingness of the whit resources
+    refreshing_c_whit = target.is_a?(whit) && target.name =~ /^completed_/
+
+    if refreshing_c_whit
+      source.debug "The container #{target} will propagate my #{callback} event"
+    else
+      source.info "Scheduling #{callback} of #{target}"
+    end
+
+    @event_queues[target] ||= {}
+    @event_queues[target][callback] ||= []
+    @event_queues[target][callback].concat(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)
+
+    if not resource.is_a?(Puppet::Type.type(:whit))
+      resource.notice "Triggered '#{callback}' from #{events.length} events"
+    end
+    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/vendor/puppet/transaction/report.rb

@@ -0,0 +1,200 @@
+require 'puppet'
+require 'puppet/indirector'
+
+# A class for reporting what happens on each client.  Reports consist of
+# two types of data:  Logs and Metrics.  Logs are the output that each
+# change produces, and Metrics are all of the numerical data involved
+# in the transaction.
+class Puppet::Transaction::Report
+  extend Puppet::Indirector
+
+  indirects :report, :terminus_class => :processor
+
+  attr_accessor :configuration_version, :host, :environment
+  attr_reader :resource_statuses, :logs, :metrics, :time, :kind, :status
+
+  # 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
+    self
+  end
+
+  def add_times(name, value)
+    @external_times[name] = value
+  end
+
+  def add_metric(name, hash)
+    metric = Puppet::Util::Metric.new(name)
+
+    hash.each do |name, value|
+      metric.newvalue(name, value)
+    end
+
+    @metrics[metric.name] = metric
+    metric
+  end
+
+  def add_resource_status(status)
+    @resource_statuses[status.resource] = status
+  end
+
+  def compute_status(resource_metrics, change_metric)
+    if (resource_metrics["failed"] || 0) > 0
+      'failed'
+    elsif change_metric > 0
+      'changed'
+    else
+      'unchanged'
+    end
+  end
+
+  def prune_internal_data
+    resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
+  end
+
+  def finalize_report
+    prune_internal_data
+
+    resource_metrics = add_metric(:resources, calculate_resource_metrics)
+    add_metric(:time, calculate_time_metrics)
+    change_metric = calculate_change_metric
+    add_metric(:changes, {"total" => change_metric})
+    add_metric(:events, calculate_event_metrics)
+    @status = compute_status(resource_metrics, change_metric)
+  end
+
+  def initialize(kind, configuration_version=nil, environment=nil)
+    @metrics = {}
+    @logs = []
+    @resource_statuses = {}
+    @external_times ||= {}
+    @host = Puppet[:node_name_value]
+    @time = Time.now
+    @kind = kind
+    @report_format = 3
+    @puppet_version = Puppet.version
+    @configuration_version = configuration_version
+    @environment = environment
+    @status = 'failed' # assume failed until the report is finalized
+  end
+
+  def name
+    host
+  end
+
+  # Provide a human readable textual summary of this report.
+  def summary
+    report = raw_summary
+
+    ret = ""
+    report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
+      ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
+
+      report[key].keys.sort { |a,b|
+        # sort by label
+        if a == :total
+          1
+        elsif b == :total
+          -1
+        else
+          report[key][a].to_s <=> report[key][b].to_s
+        end
+      }.each do |label|
+        value = report[key][label]
+        next if value == 0
+        value = "%0.2f" % value if value.is_a?(Float)
+        ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
+      end
+    end
+    ret
+  end
+
+  # Provide a raw hash summary of this report.
+  def raw_summary
+    report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version  } }
+
+    @metrics.each do |name, metric|
+      key = metric.name.to_s
+      report[key] = {}
+      metric.values.each do |name, label, value|
+        report[key][name.to_s] = value
+      end
+      report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
+    end
+    (report["time"] ||= {})["last_run"] = Time.now.tv_sec
+    report
+  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
+
+  def to_yaml_properties
+    (instance_variables - ["@external_times"])
+  end
+
+  private
+
+  def calculate_change_metric
+    resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
+  end
+
+  def calculate_event_metrics
+    metrics = Hash.new(0)
+    %w{total failure success}.each { |m| metrics[m] = 0 }
+    resource_statuses.each do |name, status|
+      metrics["total"] += status.events.length
+      status.events.each do |event|
+        metrics[event.status] += 1
+      end
+    end
+
+    metrics
+  end
+
+  def calculate_resource_metrics
+    metrics = {}
+    metrics["total"] = resource_statuses.length
+
+    # force every resource key in the report to be present
+    # even if no resources is in this given state
+    Puppet::Resource::Status::STATES.each do |state|
+      metrics[state.to_s] = 0
+    end
+
+    resource_statuses.each do |name, status|
+      Puppet::Resource::Status::STATES.each do |state|
+        metrics[state.to_s] += 1 if status.send(state)
+      end
+    end
+
+    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
+
+    @external_times.each do |name, value|
+      metrics[name.to_s.downcase] = value
+    end
+
+    metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
+
+    metrics
+  end
+end

data/lib/vendor/puppet/transaction/resource_harness.rb

@@ -0,0 +1,178 @@
+require 'puppet/resource/status'
+
+class Puppet::Transaction::ResourceHarness
+  extend Forwardable
+  def_delegators :@transaction, :relationship_graph
+
+  attr_reader :transaction
+
+  def allow_changes?(resource)
+    if resource.purging? and resource.deleting? and 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
+    else
+      true
+    end
+  end
+
+  # Used mostly for scheduling and auditing at this point.
+  def cached(resource, name)
+    Puppet::Util::Storage.cache(resource)[name]
+  end
+
+  # Used mostly for scheduling and auditing at this point.
+  def cache(resource, name, value)
+    Puppet::Util::Storage.cache(resource)[name] = value
+  end
+
+  def perform_changes(resource)
+    current = resource.retrieve_resource
+
+    cache resource, :checked, Time.now
+
+    return [] if ! allow_changes?(resource)
+
+    current_values = current.to_hash
+    historical_values = Puppet::Util::Storage.cache(resource).dup
+    desired_values = {}
+    resource.properties.each do |property|
+      desired_values[property.name] = property.should
+    end
+    audited_params = (resource[:audit] || []).map { |p| p.to_sym }
+    synced_params = []
+
+    # Record the current state in state.yml.
+    audited_params.each do |param|
+      cache(resource, param, current_values[param])
+    end
+
+    # Update the machine state & create logs/events
+    events = []
+    ensure_param = resource.parameter(:ensure)
+    if desired_values[:ensure] && !ensure_param.safe_insync?(current_values[:ensure])
+      events << apply_parameter(ensure_param, current_values[:ensure], audited_params.include?(:ensure), historical_values[:ensure])
+      synced_params << :ensure
+    elsif current_values[:ensure] != :absent
+      work_order = resource.properties # Note: only the resource knows what order to apply changes in
+      work_order.each do |param|
+        if desired_values[param.name] && !param.safe_insync?(current_values[param.name])
+          events << apply_parameter(param, current_values[param.name], audited_params.include?(param.name), historical_values[param.name])
+          synced_params << param.name
+        end
+      end
+    end
+
+    # Add more events to capture audit results
+    audited_params.each do |param_name|
+      if historical_values.include?(param_name)
+        if historical_values[param_name] != current_values[param_name] && !synced_params.include?(param_name)
+          event = create_change_event(resource.parameter(param_name), current_values[param_name], true, historical_values[param_name])
+          event.send_log
+          events << event
+        end
+      else
+        resource.property(param_name).notice "audit change: newly-recorded value #{current_values[param_name]}"
+      end
+    end
+
+    events
+  end
+
+  def create_change_event(property, current_value, do_audit, historical_value)
+    event = property.event
+    event.previous_value = current_value
+    event.desired_value = property.should
+    event.historical_value = historical_value
+
+    if do_audit
+      event.audited = true
+      event.status = "audit"
+      if historical_value != current_value
+        event.message = "audit change: previously recorded value #{property.is_to_s(historical_value)} has been changed to #{property.is_to_s(current_value)}"
+      end
+    end
+
+    event
+  end
+
+  def apply_parameter(property, current_value, do_audit, historical_value)
+    event = create_change_event(property, current_value, do_audit, historical_value)
+
+    if do_audit && historical_value && historical_value != current_value
+      brief_audit_message = " (previously recorded value was #{property.is_to_s(historical_value)})"
+    else
+      brief_audit_message = ""
+    end
+
+    if property.noop
+      event.message = "current_value #{property.is_to_s(current_value)}, should be #{property.should_to_s(property.should)} (noop)#{brief_audit_message}"
+      event.status = "noop"
+    else
+      property.sync
+      event.message = [ property.change_to_s(current_value, property.should), brief_audit_message ].join
+      event.status = "success"
+    end
+    event
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    event.status = "failure"
+
+    event.message = "change from #{property.is_to_s(current_value)} to #{property.should_to_s(property.should)} failed: #{detail}"
+    event
+  ensure
+    event.send_log
+  end
+
+  def evaluate(resource)
+    start = Time.now
+    status = Puppet::Resource::Status.new(resource)
+
+    perform_changes(resource).each do |event|
+      status << event
+    end
+
+    if status.changed? && ! resource.noop?
+      cache(resource, :synced, Time.now)
+      resource.flush if resource.respond_to?(:flush)
+    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
+end