puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/application/device.rb

@@ -195,7 +195,7 @@ Licensed under the Apache 2.0 License
 
         require 'puppet/configurer'
         configurer = Puppet::Configurer.new
-        report = configurer.run(:network_device => true, :pluginsync => Puppet[:pluginsync])
+        configurer.run(:network_device => true, :pluginsync => Puppet[:pluginsync])
       rescue => detail
         Puppet.log_exception(detail)
       ensure
@@ -210,7 +210,7 @@ Licensed under the Apache 2.0 License
   def setup_host
     @host = Puppet::SSL::Host.new
     waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
-    cert = @host.wait_for_cert(waitforcert)
+    @host.wait_for_cert(waitforcert)
   end
 
   def setup
@@ -230,7 +230,7 @@ Licensed under the Apache 2.0 License
     # but this is just a temporary band-aid.
     Puppet[:ignoreimport] = true
 
-    # We need to specify a ca location for all of the SSL-related i
+    # We need to specify a ca location for all of the SSL-related
     # indirected classes to work; in fingerprint mode we just need
     # access to the local files and we don't need a ca.
     Puppet::SSL::Host.ca_location = :remote

data/lib/puppet/application/kick.rb

@@ -157,7 +157,7 @@ with '--genconfig'.
   option requires LDAP support at this point.
 
 * --ping:
-  Do a ICMP echo against the target host. Skip hosts that don't respond
+  Do an ICMP echo against the target host. Skip hosts that don't respond
   to ping.
 
 
@@ -240,7 +240,7 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
   def run_for_host(host)
     if options[:ping]
-      out = %x{ping -c 1 #{host}}
+      %x{ping -c 1 #{host}}
       unless $CHILD_STATUS == 0
         $stderr.print "Could not contact #{host}\n"
         exit($CHILD_STATUS)

data/lib/puppet/application/master.rb

@@ -1,4 +1,6 @@
 require 'puppet/application'
+require 'puppet/daemon'
+require 'puppet/util/pidlock'
 
 class Puppet::Application::Master < Puppet::Application
 
@@ -152,10 +154,8 @@ Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
       exit(0)
     end
 
-    # Create this first-off, so we have ARGV
-    require 'puppet/daemon'
-    @daemon = Puppet::Daemon.new
-    @daemon.argv = ARGV.dup
+    # save ARGV to protect us from it being smashed later by something
+    @argv = ARGV.dup
   end
 
   def run_command
@@ -183,7 +183,6 @@ Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
   def main
     require 'etc'
-
     # Make sure we've got a localhost ssl cert
     Puppet::SSL::Host.localhost
 
@@ -200,21 +199,10 @@ Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
       end
     end
 
-    unless options[:rack]
-      require 'puppet/network/server'
-      @daemon.server = Puppet::Network::Server.new(Puppet[:bindaddress], Puppet[:masterport])
-      @daemon.daemonize if Puppet[:daemonize]
-    else
-      require 'puppet/network/http/rack'
-      @app = Puppet::Network::HTTP::Rack.new()
-    end
-
-    Puppet.notice "Starting Puppet master version #{Puppet.version}"
-
-    unless options[:rack]
-      @daemon.start
+    if options[:rack]
+      start_rack_master
     else
-      return @app
+      start_webrick_master
     end
   end
 
@@ -282,4 +270,38 @@ Copyright (c) 2012 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     setup_ssl
   end
+
+  private
+
+  # Start a master that will be using WeBrick.
+  #
+  # This method will block until the master exits.
+  def start_webrick_master
+    require 'puppet/network/server'
+    daemon = Puppet::Daemon.new(Puppet::Util::Pidlock.new(Puppet[:pidfile]))
+
+    daemon.argv = @argv
+    daemon.server = Puppet::Network::Server.new(Puppet[:bindaddress], Puppet[:masterport])
+    daemon.daemonize if Puppet[:daemonize]
+
+    announce_start_of_master
+
+    daemon.start
+  end
+
+  # Start a master that will be used for a Rack container.
+  #
+  # This method immediately returns the Rack handler that must be returned to
+  # the calling Rack container
+  def start_rack_master
+    require 'puppet/network/http/rack'
+
+    announce_start_of_master
+
+    return Puppet::Network::HTTP::Rack.new()
+  end
+
+  def announce_start_of_master
+    Puppet.notice "Starting Puppet master version #{Puppet.version}"
+  end
 end

data/lib/puppet/application/queue.rb

@@ -1,5 +1,7 @@
 require 'puppet/application'
 require 'puppet/util'
+require 'puppet/daemon'
+require 'puppet/util/pidlock'
 
 class Puppet::Application::Queue < Puppet::Application
 
@@ -10,9 +12,7 @@ class Puppet::Application::Queue < Puppet::Application
   end
 
   def preinit
-    require 'puppet/daemon'
-    @daemon = Puppet::Daemon.new
-    @daemon.argv = ARGV.dup
+    @argv = ARGV.dup
 
     # Do an initial trap, so that cancels don't get a stack trace.
 
@@ -153,6 +153,8 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
     require 'puppet/resource/catalog'
     Puppet::Resource::Catalog.indirection.terminus_class = :store_configs
 
+    daemon = Puppet::Daemon.new(Puppet::Util::Pidlock.new(Puppet[:pidfile]))
+    daemon.argv = @argv
     daemon.daemonize if Puppet[:daemonize]
 
     # We want to make sure that we don't have a cache

data/lib/puppet/bindings.rb

@@ -0,0 +1,147 @@
+# This class allows registration of named bindings that are later contributed to a layer via
+# a binding scheme.
+#
+# The intended use is for a .rb file to be placed in confdir's or module's `lib/bindings` directory structure, with a
+# name corresponding to the symbolic bindings name.
+#
+# Here are two equivalent examples, the first using chained methods (which is compact for simple cases), and the
+# second which uses a block.
+#
+# @example MyModule's lib/bindings/mymodule/default.rb
+#   Puppet::Bindings.newbindings('mymodule::default') do
+#     bind.integer.named('meaning of life').to(42)
+#   end
+#
+# @example Using blocks
+#   Puppet::Bindings.newbindings('mymodule::default') do
+#     bind do
+#       integer
+#       name 'meaning of life'
+#       to 42
+#     end
+#   end
+#
+# If access is needed to the scope, this can be declared as a block parameter.
+# @example MyModule's lib/bindings/mymodule/default.rb with scope
+#   Puppet::Bindings.newbindings('mymodule::default') do |scope|
+#     bind.integer.named('meaning of life').to("#{scope['::fqdn']} also think it is 42")
+#   end
+#
+# If late evaluation is wanted, this can be achieved by binding a puppet expression.
+# @example binding a puppet expression
+#   Puppet::Bindings.newbindings('mymodule::default') do |scope|
+#     bind.integer.named('meaning of life').to(puppet_string("${::fqdn} also think it is 42")
+#   end
+#
+# It is allowed to define methods in the block given to `newbindings`, these can be used when
+# producing bindings. (Care should naturally be taken to not override any of the already defined methods).
+# @example defining method to be used while creating bindings
+#   Puppet::Bindings.newbindings('mymodule::default') do
+#     def square(x)
+#       x * x
+#     end
+#     bind.integer.named('meaning of life squared').to(square(42))
+#   end
+#
+# For all details see {Puppet::Pops::Binder::BindingsFactory}, which is used behind the scenes.
+# @api public
+#
+class Puppet::Bindings
+  extend Enumerable
+
+  Environment = Puppet::Node::Environment
+
+  # Constructs and registers a {Puppet::Pops::Binder::Bindings::NamedBindings NamedBindings} that later can be contributed
+  # to a bindings layer in a bindings configuration via a URI. The name is symbolic, fully qualified with module name, and at least one
+  # more qualifying name (where the name `default` is used in the default bindings configuration.
+  #
+  # The given block is called with a `self` bound to an instance of {Puppet::Pops::Binder::BindingsFactory::BindingsContainerBuilder}
+  # which most notably has a `#bind` method which it turn calls a block bound to an instance of
+  # {Puppet::Pops::Binder::BindingsFactory::BindingsBuilder}.
+  # Depending on the use-case a direct chaining method calls or nested blocks may be used.
+  #
+  # @example simple bindings
+  #   Puppet::Bindings.newbindings('mymodule::default') do
+  #     bind.name('meaning of life').to(42)
+  #     bind.integer.named('port').to(8080)
+  #     bind.integer.named('apache::port').to(8080)
+  #   end
+  #
+  # The block form is more suitable for longer, more complex forms of bindings.
+  #
+  def self.newbindings(name, &block)
+    register_proc(name, block)
+  end
+
+  def self.register_proc(name, block)
+    adapter = NamedBindingsAdapter.adapt(Environment.current)
+    adapter[name] = block
+  end
+
+  # Registers a named_binding under its name
+  # @param named_bindings [Puppet::Pops::Binder::Bindings::NamedBindings] The named bindings to register.
+  # @api public
+  #
+  def self.register(named_bindings)
+    adapter = NamedBindingsAdapter.adapt(Environment.current)
+    adapter[named_bindings.name] = named_bindings
+  end
+
+  def self.resolve(scope, name)
+    entry = get(name)
+    return entry unless entry.is_a?(Proc)
+    named_bindings = Puppet::Pops::Binder::BindingsFactory.safe_named_bindings(name, scope, &entry).model
+    adapter = NamedBindingsAdapter.adapt(Environment.current)
+    adapter[named_bindings.name] = named_bindings
+    named_bindings
+  end
+
+  # Returns the named bindings with the given name, or nil if no such bindings have been registered.
+  # @param name [String] The fully qualified name of a binding to get
+  # @return [Proc, Puppet::Pops::Binder::Bindings::NamedBindings] a Proc producing named bindings, or a named bindings directly
+  # @api public
+  #
+  def self.get(name)
+    adapter = NamedBindingsAdapter.adapt(Environment.current)
+    adapter[name]
+  end
+
+  def self.[](name)
+    get(name)
+  end
+
+  # Supports Enumerable iteration (k,v) over the named bindings hash.
+  def self.each
+    adapter = NamedBindingsAdapter.adapt(Environment.current)
+    adapter.each_pair {|k,v| yield k,v }
+  end
+
+  # A NamedBindingsAdapter holds a map of name to Puppet::Pops::Binder::Bindings::NamedBindings.
+  # It is intended to be used as an association between an Environment and named bindings.
+  #
+  class NamedBindingsAdapter < Puppet::Pops::Adaptable::Adapter
+    def initialize()
+      @named_bindings = {}
+    end
+
+    def [](name)
+      @named_bindings[name]
+    end
+
+    def has_name?(name)
+      @named_bindings.has_key?
+    end
+
+    def []=(name, value)
+      unless value.is_a?(Puppet::Pops::Binder::Bindings::NamedBindings) || value.is_a?(Proc)
+        raise ArgumentError, "Given value must be a NamedBindings, or a Proc producing one, got: #{value.class}."
+      end
+      @named_bindings[name] = value
+    end
+
+    def each_pair(&block)
+      @named_bindings.each_pair(&block)
+    end
+  end
+
+end

data/lib/puppet/configurer.rb

@@ -3,6 +3,7 @@ require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
+require 'securerandom'
 
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
@@ -58,18 +59,19 @@ class Puppet::Configurer
     @running = false
     @splayed = false
     @environment = Puppet[:environment]
+    @transaction_uuid = SecureRandom.uuid
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
-  def retrieve_catalog(fact_options)
-    fact_options ||= {}
+  def retrieve_catalog(query_options)
+    query_options ||= {}
     # First try it with no cache, then with the cache.
-    unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
+    unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(query_options)) or result = retrieve_new_catalog(query_options)
       if ! Puppet[:usecacheonfailure]
         Puppet.warning "Not using cache on failed catalog"
         return nil
       end
-      result = retrieve_catalog_from_cache(fact_options)
+      result = retrieve_catalog_from_cache(query_options)
     end
 
     return nil unless result
@@ -100,11 +102,11 @@ class Puppet::Configurer
     end
   end
 
-  def prepare_and_retrieve_catalog(options, fact_options)
+  def prepare_and_retrieve_catalog(options, query_options)
     # set report host name now that we have the fact
     options[:report].host = Puppet[:node_name_value]
 
-    unless catalog = (options.delete(:catalog) || retrieve_catalog(fact_options))
+    unless catalog = (options.delete(:catalog) || retrieve_catalog(query_options))
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
@@ -116,6 +118,7 @@ class Puppet::Configurer
   def apply_catalog(catalog, options)
     report = options[:report]
     report.configuration_version = catalog.version
+    report.transaction_uuid = @transaction_uuid
     report.environment = @environment
 
     benchmark(:notice, "Finished catalog run") do
@@ -126,6 +129,10 @@ class Puppet::Configurer
     report
   end
 
+  def get_transaction_uuid
+    { :transaction_uuid => @transaction_uuid }
+  end
+
   # The code that actually runs the catalog.
   # This just passes any options on to the catalog,
   # which accepts :tags and :ignoreschedules.
@@ -137,7 +144,7 @@ class Puppet::Configurer
     Puppet::Util::Log.newdestination(report)
     begin
       unless Puppet[:node_name_fact].empty?
-        fact_options = get_facts(options)
+        query_options = get_facts(options)
       end
 
       begin
@@ -146,7 +153,7 @@ class Puppet::Configurer
           if node.environment.to_s != @environment
             Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified node environment \"#{node.environment}\", switching agent to \"#{node.environment}\"."
             @environment = node.environment.to_s
-            fact_options = nil
+            query_options = nil
           end
         end
       rescue Puppet::Error, Net::HTTPError => detail
@@ -154,9 +161,12 @@ class Puppet::Configurer
         Puppet.warning(detail)
       end
 
-      fact_options = get_facts(options) unless fact_options
+      query_options = get_facts(options) unless query_options
+
+      # add the transaction uuid to the catalog query options hash
+      query_options.merge! get_transaction_uuid if query_options
 
-      unless catalog = prepare_and_retrieve_catalog(options, fact_options)
+      unless catalog = prepare_and_retrieve_catalog(options, query_options)
         return nil
       end
 
@@ -171,7 +181,7 @@ class Puppet::Configurer
         end
         Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified environment \"#{catalog.environment}\", restarting agent run with environment \"#{catalog.environment}\""
         @environment = catalog.environment
-        return nil unless catalog = prepare_and_retrieve_catalog(options, fact_options)
+        return nil unless catalog = prepare_and_retrieve_catalog(options, query_options)
         tries += 1
       end
 
@@ -225,10 +235,10 @@ class Puppet::Configurer
     end
   end
 
-  def retrieve_catalog_from_cache(fact_options)
+  def retrieve_catalog_from_cache(query_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_terminus => true, :environment => @environment))
+      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], query_options.merge(:ignore_terminus => true, :environment => @environment))
     end
     Puppet.notice "Using cached catalog"
     result
@@ -237,10 +247,10 @@ class Puppet::Configurer
     return nil
   end
 
-  def retrieve_new_catalog(fact_options)
+  def retrieve_new_catalog(query_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_cache => true, :environment => @environment))
+      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], query_options.merge(:ignore_cache => true, :environment => @environment))
     end
     result
   rescue SystemExit,NoMemoryError

data/lib/puppet/configurer/fact_handler.rb

@@ -29,16 +29,9 @@ module Puppet::Configurer::FactHandler
 
   def facts_for_uploading
     facts = find_facts
-    #format = facts.class.default_format
 
-    if facts.support_format?(:b64_zlib_yaml)
-      format = :b64_zlib_yaml
-    else
-      format = :yaml
-    end
-
-    text = facts.render(format)
+    text = facts.render(:pson)
 
-    {:facts_format => format, :facts => CGI.escape(text)}
+    {:facts_format => :pson, :facts => CGI.escape(text)}
   end
 end