puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/status.rb

@@ -10,6 +10,10 @@ class Puppet::Status
     @status = status || {"is_alive" => true}
   end
 
+  def to_data_hash
+    @status
+  end
+
   def to_pson(*args)
     @status.to_pson
   end

data/lib/puppet/test/test_helper.rb

@@ -1,3 +1,5 @@
+require 'puppet/indirector/data_binding/hiera'
+
 module Puppet::Test
   # This class is intended to provide an API to be used by external projects
   #  when they are running tests that depend on puppet core.  This should
@@ -84,8 +86,11 @@ module Puppet::Test
       Puppet::Node::Environment.clear
       Puppet::Parser::Functions.reset
       Puppet::Application.clear!
+      Puppet::Util::Profiler.clear
 
       Puppet.clear_deprecation_warnings
+
+      Puppet::DataBinding::Hiera.instance_variable_set("@hiera", nil)
     end
 
     # Call this method once per test, after execution of each individual test.

data/lib/puppet/transaction.rb

@@ -2,6 +2,7 @@ require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/application'
 require 'digest/sha1'
+require 'set'
 
 # the class that actually walks our resource/property tree, collects the changes,
 # and performs them
@@ -58,7 +59,11 @@ class Puppet::Transaction
 
     continue_while = lambda { !stop_processing? }
 
+    post_evalable_providers = Set.new
     pre_process = lambda do |resource|
+      prov_class = resource.provider.class
+      post_evalable_providers << prov_class if prov_class.respond_to?(:post_resource_eval)
+
       prefetch_if_necessary(resource)
 
       # If we generated resources, we don't know what they are now
@@ -90,6 +95,14 @@ class Puppet::Transaction
       providerless_types.uniq.each do |type|
         Puppet.err "Could not find a suitable provider for #{type}"
       end
+
+      post_evalable_providers.each do |provider|
+        begin
+          provider.post_resource_eval
+        rescue => detail
+          Puppet.log_exception(detail, "post_resource_eval failed for provider #{provider}")
+        end
+      end
     end
 
     relationship_graph.traverse(:while => continue_while,

data/lib/puppet/transaction/event.rb

@@ -2,17 +2,18 @@ require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/util/logging'
 require 'puppet/util/methodhelper'
+require 'puppet/network/format_support'
 
 # A simple struct for storing what happens on the system.
 class Puppet::Transaction::Event
   include Puppet::Util::MethodHelper
   include Puppet::Util::Tagging
   include Puppet::Util::Logging
+  include Puppet::Network::FormatSupport
 
   ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited, :invalidate_refreshes]
   YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}.map(&:to_sym)
   attr_accessor *ATTRIBUTES
-  attr_writer :tags
   attr_accessor :time
   attr_reader :default_log_level
 
@@ -44,7 +45,7 @@ class Puppet::Transaction::Event
     @time = Time.parse(@time) if @time.is_a? String
   end
 
-  def to_pson
+  def to_data_hash
     {
       'audited' => @audited,
       'property' => @property,
@@ -55,7 +56,11 @@ class Puppet::Transaction::Event
       'name' => @name,
       'status' => @status,
       'time' => @time.iso8601(9),
-    }.to_pson
+    }
+  end
+
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
   end
 
   def property=(prop)

data/lib/puppet/transaction/report.rb

@@ -216,7 +216,7 @@ class Puppet::Transaction::Report
     end
   end
 
-  def to_pson
+  def to_data_hash
     {
       'host' => @host,
       'time' => @time.iso8601(9),
@@ -231,7 +231,11 @@ class Puppet::Transaction::Report
       'logs' => @logs,
       'metrics' => @metrics,
       'resource_statuses' => @resource_statuses,
-    }.to_pson
+    }
+  end
+
+  def to_pson
+    to_data_hash.to_pson
   end
 
   # @return [String] the host name

data/lib/puppet/transaction/resource_harness.rb

@@ -6,16 +6,50 @@ class Puppet::Transaction::ResourceHarness
 
   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
+  def initialize(transaction)
+    @transaction = transaction
+  end
+
+  def evaluate(resource)
+    status = Puppet::Resource::Status.new(resource)
+
+    begin
+      context = ResourceApplicationContext.from_resource(resource, status)
+      perform_changes(resource, context)
+
+      if status.changed? && ! resource.noop?
+        cache(resource, :synced, Time.now)
+        resource.flush if resource.respond_to?(:flush)
+      end
+    rescue => detail
+      status.failed_because(detail)
+    ensure
+      status.evaluation_time = Time.now - status.time
+    end
+
+    status
+  end
+
+  def scheduled?(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
 
   # Used mostly for scheduling and auditing at this point.
@@ -28,153 +62,177 @@ class Puppet::Transaction::ResourceHarness
     Puppet::Util::Storage.cache(resource)[name] = value
   end
 
-  def perform_changes(resource)
-    current_values = resource.retrieve_resource.to_hash
+  private
 
+  def perform_changes(resource, context)
     cache(resource, :checked, Time.now)
 
     return [] if ! allow_changes?(resource)
 
-    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])
+    context.audited_params.each do |param|
+      cache(resource, param, context.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
+    managed_via_ensure = manage_via_ensure_if_possible(resource, context)
+
+    if !managed_via_ensure
+      if context.resource_present?
+        resource.properties.each do |param|
+          sync_if_needed(param, context)
         end
+      else
+        resource.debug("Nothing to manage: no ensure and the resource doesn't exist")
       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
+    capture_audit_events(resource, context)
+  end
+
+  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
+
+  def manage_via_ensure_if_possible(resource, context)
+    ensure_param = resource.parameter(:ensure)
+    if ensure_param && ensure_param.should
+      sync_if_needed(ensure_param, context)
+    else
+      false
+    end
+  end
+
+  def sync_if_needed(param, context)
+    historical_value = context.historical_values[param.name]
+    current_value = context.current_values[param.name]
+    do_audit = context.audited_params.include?(param.name)
+
+    begin
+      if param.should && !param.safe_insync?(current_value)
+        event = create_change_event(param, current_value, historical_value)
+        if do_audit
+          event = audit_event(event, param)
+        end
+
+        brief_audit_message = audit_message(param, do_audit, historical_value, current_value)
+
+        if param.noop
+          noop(event, param, current_value, brief_audit_message)
+        else
+          sync(event, param, current_value, brief_audit_message)
         end
+
+        true
       else
-        resource.property(param_name).notice "audit change: newly-recorded value #{current_values[param_name]}"
+        false
       end
-    end
+    rescue => detail
+      # Execution will continue on StandardErrors, just store the event
+      Puppet.log_exception(detail)
 
-    events
+      event = create_change_event(param, current_value, historical_value)
+      event.status = "failure"
+      event.message = "change from #{param.is_to_s(current_value)} to #{param.should_to_s(param.should)} failed: #{detail}"
+      false
+    rescue Exception => detail
+      # Execution will halt on Exceptions, they get raised to the application
+      event = create_change_event(param, current_value, historical_value)
+      event.status = "failure"
+      event.message = "change from #{param.is_to_s(current_value)} to #{param.should_to_s(param.should)} failed: #{detail}"
+      raise
+    ensure
+      if event
+        context.record(event)
+        event.send_log
+        context.synced_params << param.name
+      end
+    end
   end
 
-  def create_change_event(property, current_value, do_audit, historical_value)
+  def create_change_event(property, current_value, 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
+    event
+  end
+
+  def audit_event(event, property)
+    event.audited = true
+    event.status = "audit"
+    if event.historical_value != event.previous_value
+      event.message = "audit change: previously recorded value #{property.is_to_s(event.historical_value)} has been changed to #{property.is_to_s(event.previous_value)}"
     end
 
     event
   end
 
-  def apply_parameter(property, current_value, do_audit, historical_value)
-    event = create_change_event(property, current_value, do_audit, historical_value)
-
+  def audit_message(param, do_audit, historical_value, current_value)
     if do_audit && historical_value && historical_value != current_value
-      brief_audit_message = " (previously recorded value was #{property.is_to_s(historical_value)})"
+      " (previously recorded value was #{param.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
-    # Execution will continue on StandardErrors, just store the event
-    Puppet.log_exception(detail)
-    event.status = "failure"
-
-    event.message = "change from #{property.is_to_s(current_value)} to #{property.should_to_s(property.should)} failed: #{detail}"
-    event
-  rescue Exception => detail
-    # Execution will halt on Exceptions, they get raised to the application
-    event.status = "failure"
-    event.message = "change from #{property.is_to_s(current_value)} to #{property.should_to_s(property.should)} failed: #{detail}"
-    raise
-  ensure
-    event.send_log
   end
 
-  def evaluate(resource)
-    status = Puppet::Resource::Status.new(resource)
+  def noop(event, param, current_value, audit_message)
+    event.message = "current_value #{param.is_to_s(current_value)}, should be #{param.should_to_s(param.should)} (noop)#{audit_message}"
+    event.status = "noop"
+  end
 
-    begin
-      perform_changes(resource).each do |event|
-        status << event
-      end
+  def sync(event, param, current_value, audit_message)
+    param.sync
+    event.message = "#{param.change_to_s(current_value, param.should)}#{audit_message}"
+    event.status = "success"
+  end
 
-      if status.changed? && ! resource.noop?
-        cache(resource, :synced, Time.now)
-        resource.flush if resource.respond_to?(:flush)
+  def capture_audit_events(resource, context)
+    context.audited_params.each do |param_name|
+      if context.historical_values.include?(param_name)
+        if context.historical_values[param_name] != context.current_values[param_name] && !context.synced_params.include?(param_name)
+          parameter = resource.parameter(param_name)
+          event = audit_event(create_change_event(parameter,
+                                                  context.current_values[param_name],
+                                                  context.historical_values[param_name]),
+                              parameter)
+          event.send_log
+          context.record(event)
+        end
+      else
+        resource.property(param_name).notice "audit change: newly-recorded value #{context.current_values[param_name]}"
       end
-    rescue => detail
-      status.failed_because(detail)
-    ensure
-      status.evaluation_time = Time.now - status.time
     end
-
-    status
   end
 
-  def initialize(transaction)
-    @transaction = transaction
-  end
-
-  def scheduled?(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
+  # @api private
+  ResourceApplicationContext = Struct.new(:current_values,
+                                          :historical_values,
+                                          :audited_params,
+                                          :synced_params,
+                                          :status) do
+    def self.from_resource(resource, status)
+      ResourceApplicationContext.new(resource.retrieve_resource.to_hash,
+                                     Puppet::Util::Storage.cache(resource).dup,
+                                     (resource[:audit] || []).map { |p| p.to_sym },
+                                     [],
+                                     status)
+    end
 
-  def schedule(resource)
-    unless resource.catalog
-      resource.warning "Cannot schedule without a schedule-containing catalog"
-      return nil
+    def resource_present?
+      current_values[:ensure] != :absent
     end
 
-    return nil unless name = resource[:schedule]
-    resource.catalog.resource(:schedule, name) || resource.fail("Could not find schedule #{name}")
+    def record(event)
+      status << event
+    end
   end
 end