puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/reference/indirection.rb

@@ -12,21 +12,62 @@ reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirect
 
     text << ind.doc + "\n\n"
 
+    text << "### Termini\n\n"
+
     Puppet::Indirector::Terminus.terminus_classes(ind.name).sort { |a,b| a.to_s <=> b.to_s }.each do |terminus|
       terminus_name = terminus.to_s
       term_class = Puppet::Indirector::Terminus.terminus_class(ind.name, terminus)
-      terminus_doc = Puppet::Util::Docs.scrub(term_class.doc)
-      text << markdown_definitionlist(terminus_name, terminus_doc)
+      if term_class
+        terminus_doc = Puppet::Util::Docs.scrub(term_class.doc)
+        text << markdown_definitionlist(terminus_name, terminus_doc)
+      else
+        Puppet.warning "Could not build docs for indirector #{name.inspect}, terminus #{terminus_name.inspect}: could not locate terminus."
+      end
     end
   end
 
   text
 end
 
-reference.header = "This is the list of all indirections, their associated terminus classes, and how you select between them.
+reference.header = <<HEADER
+
+# About Indirection
+
+Puppet's indirector support pluggable backends (termini) for a variety of key-value stores (indirections).
+Each indirection type corresponds to a particular Ruby class (the "Indirected Class" below) and values are instances of that class.
+Each instance's key is available from its `name` method.
+The termini can be local (e.g., on-disk files) or remote (e.g., using a REST interface to talk to a puppet master).
+
+An indirector has five methods, which are mapped into HTTP verbs for the REST interface:
+
+ * `find(key)` - get a single value (mapped to GET or POST with a singular endpoint)
+ * `search(key)` - get a list of matching values (mapped to GET with a plural endpoint)
+ * `head(key)` - return true if the key exists (mapped to HEAD)
+ * `destroy(key)` - remove the key van value (mapped to DELETE)
+ * `save(instance)` - write the instance to the store, using the instance's name as the key (mapped to PUT)
+
+These methods are available via the `indirection` class method on the indirected classes.  For example::
+
+  foo_cert = Puppet::SSL::Certificate.indirection.find('foo.example.com')
+
+At startup, each indirection is configured with a terminus.
+In most cases, this is the default terminus defined by the indirected class, but it can be overridden by the application or face, or overridden with the `route_file` configuration.
+The available termini differ for each indirection, and are listed below.
+
+Indirections can also have a cache, represented by a second terminus.
+This is a write-through cache: modifications are written both to the cache and to the primary terminus.
+Values fetched from the terminus are written to the cache.
+
+## Interaction with REST
+
+REST endpoints have the form `/{environment}/{indirection}/{key}`, where the indirection can be singular or plural, following normal English spelling rules.
+On the server side, REST responses are generated from the locally-configured endpoints.
+
+## Indirections and Termini
+
+Below is the list of all indirections, their associated terminus classes, and how you select between them.
 
 In general, the appropriate terminus class is selected by the application for you (e.g., `puppet agent` would always use the `rest`
 terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have `terminus setting` documentation listed with them.
 
-
-"
+HEADER

data/lib/puppet/reference/metaparameter.rb

@@ -11,8 +11,8 @@ metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "Al
   str = %{
 
 # Metaparameters
-    
-Metaparameters are parameters that work with any resource type; they are part of the 
+
+Metaparameters are parameters that work with any resource type; they are part of the
 Puppet framework itself rather than being part of the implementation of any
 given instance.  Thus, any defined metaparameter can be used with any instance
 in your manifest, including defined components.

data/lib/puppet/reports.rb

@@ -12,18 +12,18 @@ require 'puppet/util/instance_loader'
 #     def process
 #       if self.status == 'failed'
 #         msg = "failed puppet run for #{self.host} #{self.status}"
-#         . . . 
+#         . . .
 #       else
 #         . . .
 #       end
-#     end 
+#     end
 #   end
 #
 # Required configuration:
 # --
 # * A .rb file that defines a new report should be placed in the master's directory `lib/puppet/reports`
 # * The `puppet.conf` file must have `report = true` in the `[agent]` section
-# 
+#
 # @see Puppet::Transaction::Report
 # @api public
 #
@@ -43,14 +43,14 @@ class Puppet::Reports
   # The block should contain setup, and define a method with the name `process`. The `process` method is
   # called when the report is executed; the `process` method has access to report data via methods available
   # in its context where `self` is an instance of {Puppet::Transaction::Report}.
-  # 
+  #
   # For an example, see the overview of this class.
   #
   # @param name [Symbol] the name of the report (do not use whitespace in the name).
   # @param options [Hash] a hash of options
   # @option options [Boolean] :useyaml whether yaml should be used or not
   # @todo Uncertain what the options :useyaml really does; "whether yaml should be used or not", used where/how?
-  # 
+  #
   def self.register_report(name, options = {}, &block)
     name = name.intern
 

data/lib/puppet/reports/rrdgraph.rb

@@ -1,10 +1,10 @@
 Puppet::Reports.register_report(:rrdgraph) do
   desc "Graph all available data about hosts using the RRD library.  You
     must have the Ruby RRDtool library installed to use this report, which
-    you can get from 
-    [the RubyRRDTool RubyForge page](http://rubyforge.org/projects/rubyrrdtool/).  
-    This package may also be available as `ruby-rrd` or `rrdtool-ruby` in your 
-    distribution's package management system.  The library and/or package will both 
+    you can get from
+    [the RubyRRDTool RubyForge page](http://rubyforge.org/projects/rubyrrdtool/).
+    This package may also be available as `ruby-rrd` or `rrdtool-ruby` in your
+    distribution's package management system.  The library and/or package will both
     require the binary `rrdtool` package from your distribution to be installed.
 
     This report will create, manage, and graph RRD database files for each

data/lib/puppet/reports/tagmail.rb

@@ -6,7 +6,7 @@ require 'time'
 
 Puppet::Reports.register_report(:tagmail) do
   desc "This report sends specific log messages to specific email addresses
-    based on the tags in the log messages.  
+    based on the tags in the log messages.
 
     See the [documentation on tags](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information.
 

data/lib/puppet/resource.rb

@@ -313,7 +313,7 @@ class Puppet::Resource
   #
   # Example:
   #
-  #   class foo($port){ ... }
+  #   class foo($port=0){ ... }
   #
   # We make a request to the backend for the key 'foo::port' not 'foo'
   #

data/lib/puppet/resource/type.rb

@@ -1,8 +1,9 @@
-require 'puppet/parser/parser'
+require 'puppet/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
 require 'puppet/util/inline_docs'
 require 'puppet/parser/ast/leaf'
+require 'puppet/parser/ast/block_expression'
 require 'puppet/dsl'
 
 class Puppet::Resource::Type
@@ -190,14 +191,15 @@ class Puppet::Resource::Type
       return
     end
 
-    array_class = Puppet::Parser::AST::ASTArray
-    self.code = array_class.new(:children => [self.code]) unless self.code.is_a?(array_class)
-
-    if other.code.is_a?(array_class)
-      code.children += other.code.children
-    else
-      code.children << other.code
-    end
+    self.code = Puppet::Parser::AST::BlockExpression.new(:children => [self.code, other.code])
+#    array_class = Puppet::Parser::AST::ASTArray
+#    self.code = array_class.new(:children => [self.code]) unless self.code.is_a?(array_class)
+#
+#    if other.code.is_a?(array_class)
+#      code.children += other.code.children
+#    else
+#      code.children << other.code
+#    end
   end
 
   # Make an instance of the resource type, and place it in the catalog
@@ -260,10 +262,10 @@ class Puppet::Resource::Type
 
   # MQR TODO:
   #
-  # The change(s) introduced by the fix for #4270 are mostly silly & should be 
+  # The change(s) introduced by the fix for #4270 are mostly silly & should be
   # removed, though we didn't realize it at the time.  If it can be established/
   # ensured that nodes never call parent_type and that resource_types are always
-  # (as they should be) members of exactly one resource_type_collection the 
+  # (as they should be) members of exactly one resource_type_collection the
   # following method could / should be replaced with:
   #
   # def parent_type

data/lib/puppet/scheduler.rb

@@ -0,0 +1,16 @@
+module Puppet::Scheduler
+  require 'puppet/scheduler/job'
+  require 'puppet/scheduler/splay_job'
+  require 'puppet/scheduler/scheduler'
+  require 'puppet/scheduler/timer'
+
+  module_function
+
+  def create_job(interval, splay=false, splay_limit=0, &block)
+    if splay
+      Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
+    else
+      Puppet::Scheduler::Job.new(interval, &block)
+    end
+  end
+end

data/lib/puppet/scheduler/job.rb

@@ -0,0 +1,53 @@
+module Puppet::Scheduler
+  class Job
+    attr_reader :run_interval
+    attr_accessor :last_run
+    attr_accessor :start_time
+
+    def initialize(run_interval, &block)
+      self.run_interval = run_interval
+      @last_run = nil
+      @run_proc = block
+      @enabled = true
+    end
+
+    def run_interval=(interval)
+      @run_interval = [interval, 0].max
+    end
+
+    def ready?(time)
+      if @last_run
+        @last_run + @run_interval <= time
+      else
+        true
+      end
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def interval_to_next_from(time)
+      if ready?(time)
+        0
+      else
+        @run_interval - (time - @last_run)
+      end
+    end
+
+    def run(now)
+      @last_run = now
+      if @run_proc
+        @run_proc.call(self)
+      end
+    end
+  end
+end

data/lib/puppet/scheduler/scheduler.rb

@@ -0,0 +1,45 @@
+module Puppet::Scheduler
+  class Scheduler
+    def initialize(jobs, timer=Puppet::Scheduler::Timer.new)
+      @timer = timer
+      @jobs = jobs
+    end
+
+    def run_loop
+      mark_start_times(@timer.now)
+      while not enabled_jobs.empty?
+        @timer.wait_for(min_interval_to_next_run_from(@timer.now))
+        run_ready(@timer.now)
+      end
+    end
+
+    private
+
+    def enabled_jobs
+      @jobs.select(&:enabled?)
+    end
+
+    def mark_start_times(start_time)
+      @jobs.each do |job|
+        job.start_time = start_time
+      end
+    end
+
+    def min_interval_to_next_run_from(from_time)
+      enabled_jobs.map do |j|
+        j.interval_to_next_from(from_time)
+      end.min
+    end
+
+    def run_ready(at_time)
+      enabled_jobs.each do |j|
+        # This check intentionally happens right before each run,
+        # instead of filtering on ready schedulers, since one may adjust
+        # the readiness of a later one
+        if j.ready?(at_time)
+          j.run(at_time)
+        end
+      end
+    end
+  end
+end

data/lib/puppet/scheduler/splay_job.rb

@@ -0,0 +1,32 @@
+module Puppet::Scheduler
+  class SplayJob < Job
+    attr_reader :splay
+
+    def initialize(run_interval, splay_limit, &block)
+      @splay = calculate_splay(splay_limit)
+      super(run_interval, &block)
+    end
+
+    def interval_to_next_from(time)
+      if last_run
+        super
+      else
+        (start_time + splay) - time
+      end
+    end
+
+    def ready?(time)
+      if last_run
+        super
+      else
+        start_time + splay <= time
+      end
+    end
+
+    private
+
+    def calculate_splay(limit)
+      rand(limit + 1)
+    end
+  end
+end

data/lib/puppet/scheduler/timer.rb

@@ -0,0 +1,13 @@
+module Puppet::Scheduler
+  class Timer
+    def wait_for(seconds)
+      if seconds > 0
+        select([], [], [], seconds)
+      end
+    end
+
+    def now
+      Time.now
+    end
+  end
+end

data/lib/puppet/settings/base_setting.rb

@@ -23,7 +23,7 @@ class Puppet::Settings::BaseSetting
       Puppet.deprecation_warning ":call_on_define has been changed to :call_hook => :on_define_and_write. Please change #{name}."
       @call_hook = :on_define_and_write
     else
-      Puppet.deprecation_warning ":call_on_define => :false has been changed to :call_hook => :on_write_only. Please change #{name}." 
+      Puppet.deprecation_warning ":call_on_define => :false has been changed to :call_hook => :on_write_only. Please change #{name}."
       @call_hook = :on_write_only
     end
   end

data/lib/puppet/simple_graph.rb

@@ -19,7 +19,7 @@ class Puppet::SimpleGraph
   #
   # This class is intended to be used with DAGs.  However, if the
   # graph has a cycle, it will not cause non-termination of any of the
-  # algorithms.  
+  # algorithms.
   #
   def initialize
     @in_to = {}
@@ -376,7 +376,7 @@ class Puppet::SimpleGraph
   end
 
   def direct_dependents_of(v)
-    (@out_from[v] || {}).keys 
+    (@out_from[v] || {}).keys
   end
 
   def upstream_from_vertex(v)
@@ -390,7 +390,7 @@ class Puppet::SimpleGraph
   end
 
   def direct_dependencies_of(v)
-    (@in_to[v] || {}).keys 
+    (@in_to[v] || {}).keys
   end
 
   # Return an array of the edge-sets between a series of n+1 vertices (f=v0,v1,v2...t=vn)
@@ -404,7 +404,7 @@ class Puppet::SimpleGraph
   #     * if there is no path from f to t, the result is nil
   #
   # This implementation is not particularly efficient; it's used in testing where clarity
-  #   is more important than last-mile efficiency. 
+  #   is more important than last-mile efficiency.
   #
   def path_between(f,t)
     if f==t

data/lib/puppet/ssl/base.rb

@@ -1,6 +1,7 @@
 require 'openssl'
 require 'puppet/ssl'
 require 'puppet/ssl/digest'
+require 'puppet/util/ssl'
 
 # The base class for wrapping SSL instances.
 class Puppet::SSL::Base
@@ -47,9 +48,18 @@ class Puppet::SSL::Base
     self.class.validate_certname(@name)
   end
 
-  # Method to extract a 'name' from the subject of a certificate
+  ##
+  # name_from_subject extracts the common name attribute from the subject of an
+  # x.509 certificate certificate
+  #
+  # @api private
+  #
+  # @param [OpenSSL::X509::Name] subject The full subject (distinguished name) of the x.509
+  #   certificate.
+  #
+  # @return [String] the name (CN) extracted from the subject.
   def self.name_from_subject(subject)
-    subject.to_s.sub(/\/CN=/i, '')
+    Puppet::Util::SSL.cn_from_subject(subject)
   end
 
   # Create an instance of our Puppet::SSL::* class using a given instance of the wrapped class