puppet 0.24.7 → 0.24.8

data/lib/puppet/network/xmlrpc/client.rb

@@ -36,57 +36,7 @@ module Puppet::Network
             interface.methods.each { |ary|
                 method = ary[0]
                 newclient.send(:define_method,method) { |*args|
-                    Puppet.debug "Calling %s.%s" % [namespace, method]
-                    begin
-                        call("%s.%s" % [namespace, method.to_s],*args)
-                    rescue OpenSSL::SSL::SSLError => detail
-                        if detail.message =~ /bad write retry/
-                            Puppet.warning "Transient SSL write error; restarting connection and retrying"
-                            self.recycle_connection
-                            retry
-                        end
-                        ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
-                            if detail.message.include?(str)
-                                Puppet.warning "Certificate validation failed; consider using the certname configuration option"
-                            end
-                        end 
-                        raise XMLRPCClientError,
-                            "Certificates were not trusted: %s" % detail
-                    rescue ::XMLRPC::FaultException => detail
-                        raise XMLRPCClientError, detail.faultString
-                    rescue Errno::ECONNREFUSED => detail
-                        msg = "Could not connect to %s on port %s" %
-                            [@host, @port]
-                        raise XMLRPCClientError, msg
-                    rescue SocketError => detail
-                        Puppet.err "Could not find server %s: %s" %
-                            [@host, detail.to_s]
-                        error = XMLRPCClientError.new(
-                            "Could not find server %s" % @host
-                        )
-                        error.set_backtrace detail.backtrace
-                        raise error
-                    rescue Errno::EPIPE, EOFError
-                        Puppet.warning "Other end went away; restarting connection and retrying"
-                        self.recycle_connection
-                        retry
-                    rescue Timeout::Error => detail
-                        Puppet.err "Connection timeout calling %s.%s: %s" %
-                            [namespace, method, detail.to_s]
-                        error = XMLRPCClientError.new("Connection Timeout")
-                        error.set_backtrace(detail.backtrace)
-                        raise error
-                    rescue => detail
-                        if detail.message =~ /^Wrong size\. Was \d+, should be \d+$/
-                            Puppet.warning "XMLRPC returned wrong size.  Retrying."
-                            retry
-                        end    
-                        Puppet.err "Could not call %s.%s: %s" %
-                            [namespace, method, detail.inspect]
-                        error = XMLRPCClientError.new(detail.to_s)
-                        error.set_backtrace detail.backtrace
-                        raise error
-                    end
+                    make_rpc_call(namespace, method, *args)
                 }
             }
 
@@ -97,13 +47,119 @@ module Puppet::Network
             @clients[handler] || self.mkclient(handler)
         end
 
+        class ErrorHandler
+            def initialize(&block)
+                metaclass.define_method(:execute, &block)
+            end
+        end
+
+        # Use a class variable so all subclasses have access to it.
+        @@error_handlers = {}
+
+        def self.error_handler(exception)
+            if handler = @@error_handlers[exception.class]
+                return handler
+            else
+                return @@error_handlers[:default]
+            end
+        end
+
+        def self.handle_error(*exceptions, &block)
+            handler = ErrorHandler.new(&block)
+
+            exceptions.each do |exception|
+                @@error_handlers[exception] = handler
+            end
+        end
+
+        handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
+            if detail.message =~ /bad write retry/
+                Puppet.warning "Transient SSL write error; restarting connection and retrying"
+                client.recycle_connection
+                return :retry
+            end
+            ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
+                if detail.message.include?(str)
+                    Puppet.warning "Certificate validation failed; consider using the certname configuration option"
+                end
+            end 
+            raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
+        end
+
+        handle_error(:default) do |client, detail, namespace, method|
+            if detail.message.to_s =~ /^Wrong size\. Was \d+, should be \d+$/
+                Puppet.warning "XMLRPC returned wrong size.  Retrying."
+                return :retry
+            end    
+            Puppet.err "Could not call %s.%s: %s" % [namespace, method, detail.inspect]
+            error = XMLRPCClientError.new(detail.to_s)
+            error.set_backtrace detail.backtrace
+            raise error
+        end
+
+        handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
+            if detail.message =~ /bad write retry/
+                Puppet.warning "Transient SSL write error; restarting connection and retrying"
+                client.recycle_connection
+                return :retry
+            end
+            ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
+                if detail.message.include?(str)
+                    Puppet.warning "Certificate validation failed; consider using the certname configuration option"
+                end
+            end 
+            raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
+        end
+
+        handle_error(::XMLRPC::FaultException) do |client, detail, namespace, method|
+            raise XMLRPCClientError, detail.faultString
+        end
+
+        handle_error(Errno::ECONNREFUSED) do |client, detail, namespace, method|
+            msg = "Could not connect to %s on port %s" % [client.host, client.port]
+            raise XMLRPCClientError, msg
+        end
+
+        handle_error(SocketError) do |client, detail, namespace, method|
+            Puppet.err "Could not find server %s: %s" % [@host, detail.to_s]
+            error = XMLRPCClientError.new("Could not find server %s" % client.host)
+            error.set_backtrace detail.backtrace
+            raise error
+        end
+
+        handle_error(Errno::EPIPE, EOFError) do |client, detail, namespace, method|
+            Puppet.info "Other end went away; restarting connection and retrying"
+            client.recycle_connection
+            return :retry
+        end
+
+        handle_error(Timeout::Error) do |client, detail, namespace, method|
+            Puppet.err "Connection timeout calling %s.%s: %s" % [namespace, method, detail.to_s]
+            error = XMLRPCClientError.new("Connection Timeout")
+            error.set_backtrace(detail.backtrace)
+            raise error
+        end
+
+        def make_rpc_call(namespace, method, *args)
+            Puppet.debug "Calling %s.%s" % [namespace, method]
+            begin
+                call("%s.%s" % [namespace, method.to_s],*args)
+            rescue Exception => detail
+                retry if self.class.error_handler(detail).execute(self, detail, namespace, method) == :retry
+            end
+        ensure
+            http.finish if http.started?
+        end
+
         def http
             unless @http
-                @http = Puppet::Network::HttpPool.http_instance(@host, @port, true)
+                @http = Puppet::Network::HttpPool.http_instance(host, port, true)
             end
             @http
         end
 
+        attr_reader :host, :port
+
         def initialize(hash = {})
             hash[:Path] ||= "/RPC2"
             hash[:Server] ||= Puppet[:server]
@@ -135,7 +191,11 @@ module Puppet::Network
         # or we've just downloaded certs and we need to create new http instances
         # with the certs added.
         def recycle_connection
-            @http = Puppet::Network::HttpPool.http_instance(@host, @port, true) # reset the instance
+            if http.started?
+                http.finish
+            end
+            @http = nil
+            self.http # force a new one
         end
         
         def start

data/lib/puppet/parser/ast.rb

@@ -2,6 +2,7 @@
 
 require 'puppet'
 require 'puppet/util/autoload'
+require 'puppet/file_collection/lookup'
 
 # The base class for all of the objects that make up the parse trees.
 # Handles things like file name, line #, and also does the initialization
@@ -10,11 +11,13 @@ class Puppet::Parser::AST
     # Do this so I don't have to type the full path in all of the subclasses
     AST = Puppet::Parser::AST
 
+    include Puppet::FileCollection::Lookup
+
     include Puppet::Util::Errors
     include Puppet::Util::MethodHelper
     include Puppet::Util::Docs
 
-    attr_accessor :line, :file, :parent, :scope
+    attr_accessor :parent, :scope
 
     # don't fetch lexer comment by default
     def use_docs
@@ -82,8 +85,6 @@ class Puppet::Parser::AST
     # method for them.  This is probably pretty inefficient and should
     # likely be changed at some point.
     def initialize(args)
-        @file = nil
-        @line = nil
         set_options(args)
     end
 end

data/lib/puppet/parser/ast/astarray.rb

@@ -30,9 +30,10 @@ class Puppet::Parser::AST
                     items << child
                 end
             }
+
             rets = items.flatten.collect { |child|
                 child.safeevaluate(scope)
-            }.flatten
+            }
             return rets.reject { |o| o.nil? }
         end
 

data/lib/puppet/parser/ast/leaf.rb

@@ -36,7 +36,7 @@ class Puppet::Parser::AST
         # Interpolate the string looking for variables, and then return
         # the result.
         def evaluate(scope)
-            return scope.strinterp(@value, @file, @line)
+            return scope.strinterp(@value, file, line)
         end
     end
 

data/lib/puppet/parser/ast/resource.rb

@@ -18,34 +18,34 @@ class Resource < AST::ResourceReference
             param.safeevaluate(scope)
         }
 
-        objtitles = @title.safeevaluate(scope)
+        resource_titles = @title.safeevaluate(scope)
 
         # it's easier to always use an array, even for only one name
-        unless objtitles.is_a?(Array)
-            objtitles = [objtitles]
+        unless resource_titles.is_a?(Array)
+            resource_titles = [resource_titles]
         end
 
-        objtype = qualified_type(scope)
+        resource_type = qualified_type(scope)
+
+        # We want virtual to be true if exported is true.  We can't
+        # just set :virtual => self.virtual in the initialization,
+        # because sometimes the :virtual attribute is set *after*
+        # :exported, in which case it clobbers :exported if :exported
+        # is true.  Argh, this was a very tough one to track down.
+        virt = self.virtual || self.exported
 
         # This is where our implicit iteration takes place; if someone
         # passed an array as the name, then we act just like the called us
         # many times.
-        objtitles.collect { |objtitle|
+        resource_titles.flatten.collect { |resource_title|
             exceptwrap :type => Puppet::ParseError do
-                exp = self.exported || scope.resource.exported?
-                # We want virtual to be true if exported is true.  We can't
-                # just set :virtual => self.virtual in the initialization,
-                # because sometimes the :virtual attribute is set *after*
-                # :exported, in which case it clobbers :exported if :exported
-                # is true.  Argh, this was a very tough one to track down.
-                virt = self.virtual || scope.resource.virtual? || exp
-                obj = Puppet::Parser::Resource.new(
-                    :type => objtype,
-                    :title => objtitle,
+                resource = Puppet::Parser::Resource.new(
+                    :type => resource_type,
+                    :title => resource_title,
                     :params => paramobjects,
                     :file => self.file,
                     :line => self.line,
-                    :exported => exp,
+                    :exported => self.exported,
                     :virtual => virt,
                     :source => scope.source,
                     :scope => scope
@@ -53,11 +53,11 @@ class Resource < AST::ResourceReference
 
                 # And then store the resource in the compiler.
                 # At some point, we need to switch all of this to return
-                # objects instead of storing them like this.
-                scope.compiler.add_resource(scope, obj)
-                obj
+                # resources instead of storing them like this.
+                scope.compiler.add_resource(scope, resource)
+                resource
             end
-        }.reject { |obj| obj.nil? }
+        }.reject { |resource| resource.nil? }
     end
 
     # Set the parameters for our object.

data/lib/puppet/parser/ast/resource_override.rb

@@ -40,8 +40,8 @@ class Puppet::Parser::AST
                     :type => r.type,
                     :title => r.title,
                     :params => params,
-                    :file => @file,
-                    :line => @line,
+                    :file => file,
+                    :line => line,
                     :source => scope.source,
                     :scope => scope
                 )

data/lib/puppet/parser/collector.rb

@@ -72,8 +72,7 @@ class Puppet::Parser::Collector
     def collect_exported
         # First get everything from the export table.  Just reuse our
         # collect_virtual method but tell it to use 'exported? for the test.
-        resources = collect_virtual(true).reject { |r| ! r.virtual? }.each { |r| r.exported = false }
-        #resources = collect_virtual(true).reject { |r| ! r.virtual? }
+        resources = collect_virtual(true).reject { |r| ! r.virtual? }
 
         count = resources.length
 

data/lib/puppet/parser/functions/realize.rb

@@ -8,7 +8,7 @@ Puppet::Parser::Functions::newfunction(:realize, :doc => "Make a virtual object
         reference; e.g.: ``realize User[luke]``." ) do |vals|
         coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)
         vals = [vals] unless vals.is_a?(Array)
-        coll.resources = vals
+        coll.resources = vals.flatten
 
         compiler.add_collection(coll)
 end

data/lib/puppet/parser/functions/regsubst.rb

@@ -0,0 +1,93 @@
+module Puppet::Parser::Functions
+    newfunction(:regsubst, :type => :rvalue,
+		:doc => "\
+	Perform regexp replacement on a string.
+
+	Parameters (in order):
+
+	:str:
+		The string to operate on.
+
+	:regexp:
+		The regular expression matching the string.  If you want it
+		anchored at the start and/or end of the string, you must do
+		that with ^ and $ yourself.
+
+	:replacement:
+		Replacement string.  Can contain back references to what was
+		matched using \\0, \\1, and so on.
+
+	:flags:
+		Optional.  String of single letter flags for how the regexp
+		is interpreted:
+
+		- **E**
+			Extended regexps
+		- **I**
+			Ignore case in regexps
+		- **M**
+			Multiline regexps
+		- **G**
+			Global replacement; all occurances of the regexp in
+			the string will be replaced.  Without this, only the
+			first occurance will be replaced.
+
+	:lang:
+		Optional.  How to handle multibyte characters.  A
+		single-character string with the following values:
+
+		- **N**
+			None
+		- **E**
+			EUC
+		- **S**
+			SJIS
+		- **U**
+			UTF-8
+
+	**Examples**
+
+	Get the third octet from the node's IP address: ::
+
+	    $i3 = regsubst($ipaddress,
+			   '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
+			   '\\\\3')
+
+	Put angle brackets around each octet in the node's IP address: ::
+
+	    $x = regsubst($ipaddress, '([0-9]+)', '<\\\\1>', 'G')
+	") \
+    do |args|
+	flag_mapping = {
+	    "E" => Regexp::EXTENDED,
+	    "I" => Regexp::IGNORECASE,
+	    "M" => Regexp::MULTILINE,
+	}
+	if args.length < 3  or  args.length > 5
+	    raise Puppet::ParseError, ("regsub(): wrong number of arguments" +
+				       " (#{args.length}; min 3, max 5)")
+	end
+	str, regexp, replacement, flags, lang = args
+	reflags = 0
+	global = false
+	(flags or "").each_byte do |f|
+	    f = f.chr
+	    if f == "G"
+		global = true
+	    else
+		fvalue = flag_mapping[f]
+		if !fvalue
+		    raise Puppet::ParseError, "regsub(): bad flag `#{f}'"
+		end
+		reflags |= fvalue
+	    end
+	end
+	re = Regexp.compile(regexp, reflags, lang)
+	if global
+	    result = str.gsub(re, replacement)
+	else
+	    result = str.sub(re, replacement)
+	end
+	return result
+    end
+end