puppet 0.25.0 → 0.25.1

data/lib/puppet/network/formats.rb

@@ -26,9 +26,51 @@ Puppet::Network::FormatHandler.create(:yaml, :mime => "text/yaml") do
         yaml
     end
 
-    # Everything's supported
+    # Everything's supported unless you're on 1.8.1
     def supported?(klass)
-        true
+        RUBY_VERSION != '1.8.1'
+    end
+
+    # fixup invalid yaml as per:
+    # http://redmine.ruby-lang.org/issues/show/1331
+    def fixup(yaml)
+        yaml.gsub!(/((?:&id\d+\s+)?!ruby\/object:.*?)\s*\?/) { "? #{$1}" }
+        yaml
+    end
+end
+
+# This is a "special" format which is used for the moment only when sending facts
+# as REST GET parameters (see Puppet::Configurer::FactHandler).
+# This format combines a yaml serialization, then zlib compression and base64 encoding.
+Puppet::Network::FormatHandler.create(:b64_zlib_yaml, :mime => "text/b64_zlib_yaml") do
+    require 'base64'
+    require 'zlib'
+
+    def intern(klass, text)
+        decode(text)
+    end
+
+    def intern_multiple(klass, text)
+        decode(text)
+    end
+
+    def render(instance)
+        yaml = instance.to_yaml
+
+        yaml = encode(fixup(yaml)) unless yaml.nil?
+        yaml
+    end
+
+    def render_multiple(instances)
+        yaml = instances.to_yaml
+
+        yaml = encode(fixup(yaml)) unless yaml.nil?
+        yaml
+    end
+
+    # Because of yaml issue in ruby 1.8.1...
+    def supported?(klass)
+        RUBY_VERSION != '1.8.1'
     end
 
     # fixup invalid yaml as per:
@@ -37,6 +79,14 @@ Puppet::Network::FormatHandler.create(:yaml, :mime => "text/yaml") do
         yaml.gsub!(/((?:&id\d+\s+)?!ruby\/object:.*?)\s*\?/) { "? #{$1}" }
         yaml
     end
+
+    def encode(text)
+        Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
+    end
+
+    def decode(yaml)
+        YAML.load(Zlib::Inflate.inflate(Base64.decode64(yaml)))
+    end
 end
 
 
@@ -89,22 +139,22 @@ Puppet::Network::FormatHandler.create(:raw, :mime => "application/x-raw", :weigh
     end
 end
 
-Puppet::Network::FormatHandler.create(:json, :mime => "text/json", :weight => 10, :required_methods => [:render_method, :intern_method]) do
-    confine :true => Puppet.features.json?
+Puppet::Network::FormatHandler.create(:pson, :mime => "text/pson", :weight => 10, :required_methods => [:render_method, :intern_method]) do
+    confine :true => Puppet.features.pson?
 
     def intern(klass, text)
-        data_to_instance(klass, JSON.parse(text))
+        data_to_instance(klass, PSON.parse(text))
     end
 
     def intern_multiple(klass, text)
-        JSON.parse(text).collect do |data|
+        PSON.parse(text).collect do |data|
             data_to_instance(klass, data)
         end
     end
 
-    # JSON monkey-patches Array, so this works.
+    # PSON monkey-patches Array, so this works.
     def render_multiple(instances)
-        instances.to_json
+        instances.to_pson
     end
 
     # If they pass class information, we want to ignore it.  By default,
@@ -118,6 +168,6 @@ Puppet::Network::FormatHandler.create(:json, :mime => "text/json", :weight => 10
         if data.is_a?(klass)
             return data
         end
-        klass.from_json(data)
+        klass.from_pson(data)
     end
 end

data/lib/puppet/network/http/mongrel/rest.rb

@@ -50,16 +50,17 @@ class Puppet::Network::HTTP::MongrelREST < Mongrel::HttpHandler
 
     # produce the body of the response
     def set_response(response, result, status = 200)
-        args = [status]
-
         # Set the 'reason' (or 'message', as it's called in Webrick), when
-        # we have a failure.
-        if status >= 300
-            args << false << result
-        end
-
-        response.start(*args) do |head, body|
-            body.write(result)
+        # we have a failure, unless we're on a version of mongrel that doesn't
+        # support this.
+        if status < 300
+            response.start(status) { |head, body| body.write(result) }
+        else
+            begin
+                response.start(status,false,result) { |head, body| body.write(result) }
+            rescue ArgumentError
+	        response.start(status)              { |head, body| body.write(result) }
+            end
         end
     end
 

data/lib/puppet/network/http/webrick.rb

@@ -31,13 +31,20 @@ class Puppet::Network::HTTP::WEBrick
         arguments.merge!(setup_ssl)
 
         @server = WEBrick::HTTPServer.new(arguments)
+        @server.listeners.each { |l| l.start_immediately = false }
 
         setup_handlers
 
         @mutex.synchronize do
             raise "WEBrick server is already listening" if @listening
             @listening = true
-            @thread = Thread.new { @server.start }
+            @thread = Thread.new {
+                @server.start { |sock|
+                    raise "Client disconnected before connection could be established" unless IO.select([sock],nil,nil,0.1)
+                    sock.accept
+                    @server.run(sock)
+                }
+           }
         end
     end
 

data/lib/puppet/network/http/webrick/rest.rb

@@ -50,11 +50,8 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
     def set_response(response, result, status = 200)
         response.status = status
-        if status >= 200 and status < 300
-            response.body = result
-        else
-            response.reason_phrase = result
-        end
+        response.body          = result if status >= 200 and status != 304
+        response.reason_phrase = result if status < 200 or status >= 300
     end
 
     # Retrieve node/cert/ip information from the request object.

data/lib/puppet/network/http_server/webrick.rb

@@ -21,13 +21,10 @@ module Puppet
             # with them, with flags appropriate for checking client
             # certificates for revocation
             def x509store
-                if Puppet[:cacrl] == 'false'
+                unless File.exist?(Puppet[:cacrl])
                     # No CRL, no store needed
                     return nil
                 end
-                unless File.exist?(Puppet[:cacrl])
-                    raise Puppet::Error, "Could not find CRL; set 'cacrl' to 'false' to disable CRL usage"
-                end
                 crl = OpenSSL::X509::CRL.new(File.read(Puppet[:cacrl]))
                 store = OpenSSL::X509::Store.new
                 store.purpose = OpenSSL::X509::PURPOSE_ANY

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

@@ -102,9 +102,7 @@ class Puppet::Parser::AST
         end
 
         def to_classname
-            classname = @value.to_s.downcase
-            classname.gsub!(/[^-a-zA-Z0-9:.]/,'') if regex?
-            classname
+            to_s.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
         end
 
         # implementing eql? and hash so that when an HostName is stored

data/lib/puppet/parser/collector.rb

@@ -102,18 +102,24 @@ class Puppet::Parser::Collector
         raise Puppet::DevError, "Cannot collect resources for a nil host" unless @scope.host
         host = Puppet::Rails::Host.find_by_name(@scope.host)
 
-        query = {:include => {:param_values => :param_name}}
-
         search = "(exported=? AND restype=?)"
         values = [true, @type]
 
         search += " AND (%s)" % @equery if @equery
 
-        # this is a small performance optimisation
-        # the tag mechanism involves 3 more joins, which are
-        # needed only if we query on tags.
-        if search =~ /puppet_tags/
-            query[:include][:puppet_tags] = :resource_tags
+        # note:
+        # we're not eagerly including any relations here because
+        # it can creates so much objects we'll throw out later.
+        # We used to eagerly include param_names/values but the way
+        # the search filter is built ruined those efforts and we
+        # were eagerly loading only the searched parameter and not
+        # the other ones. 
+        query = {}
+        case search
+        when /puppet_tags/
+            query = {:joins => {:resource_tags => :puppet_tag}}
+        when /param_name/
+            query = {:joins => {:param_values => :param_name}}
         end
 
         # We're going to collect objects from rails, but we don't want any
@@ -139,7 +145,7 @@ class Puppet::Parser::Collector
         # and such, we'll need to vary the conditions, but this works with no
         # attributes, anyway.
         time = Puppet::Util.thinmark do
-            Puppet::Rails::Resource.find(:all, @type, true, query).each do |obj|
+            Puppet::Rails::Resource.find(:all, query).each do |obj|
                 if resource = exported_resource(obj)
                     count += 1
                     resources << resource

data/lib/puppet/parser/compiler.rb

@@ -415,6 +415,9 @@ class Puppet::Parser::Compiler
 
         # local resource array to maintain resource ordering
         @resources = []
+
+        # Make sure any external node classes are in our class list
+        @catalog.add_class(*@node.classes)
     end
 
     # Set the node's parameters into the top-scope as variables.
@@ -422,6 +425,10 @@ class Puppet::Parser::Compiler
         node.parameters.each do |param, value|
             @topscope.setvar(param, value)
         end
+
+        # These might be nil.
+        catalog.client_version = node.parameters["clientversion"]
+        catalog.server_version = node.parameters["serverversion"]
     end
 
     # Return an array of all of the unevaluated resources.  These will be definitions,

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

@@ -1,15 +1,9 @@
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
     "Generates random numbers based on the node's fqdn. The first argument
-    sets the range.  The second argument specifies a number to add to the
-    seed and is optional.") do |args|
+    sets the range.  Additional (optional) arguments may be used to further 
+    distinguish the seed.") do |args|
         require 'md5'
-        max = args[0]
-        if args[1] then
-             seed = args[1]
-        else
-             seed = 1
-        end
-        fqdn_seed = MD5.new(lookupvar('fqdn')).to_s.hex
-        srand(seed+fqdn_seed)
+        max = args.shift
+        srand MD5.new([lookupvar('fqdn'),args].join(':')).to_s.hex
         rand(max).to_s
 end

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

@@ -1,22 +1,22 @@
 module Puppet::Parser::Functions
     newfunction(:regsubst, :type => :rvalue,
                 :doc => "
-                Perform regexp replacement on a string.
+                Perform regexp replacement on a string or array of strings.
 
 - **Parameters** (in order):
 
-:str:  The string to operate on.
+:target:  The string or array of strings to operate on.  If an array, the replacement will be performed on each of the elements in the array, and the return value will be an array.
 
-: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.
+:regexp:  The regular expression matching the target 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.
+: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 occurrences of the regexp in the string will be replaced.  Without this, only the first occurrence will be replaced.
+    - **G**         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
 
 :lang:  Optional.  How to handle multibyte characters.  A single-character string with the following values:
 
@@ -35,36 +35,50 @@ 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)")
+    do |args|
+        unless args.length.between?(3, 5)
+            raise(Puppet::ParseError,
+                  "regsubst(): got #{args.length} arguments, expected 3 to 5")
         end
-        str, regexp, replacement, flags, lang = args
+        target, 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
+        operation = :sub
+        if flags == nil
+            flags = []
+        elsif flags.respond_to?(:split)
+            flags = flags.split('')
+        else
+            raise(Puppet::ParseError,
+                  "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
+        end
+        flags.each do |f|
+            case f
+            when 'G' then operation = :gsub
+            when 'E' then reflags |= Regexp::EXTENDED
+            when 'I' then reflags |= Regexp::IGNORECASE
+            when 'M' then reflags |= Regexp::MULTILINE
+            else raise(Puppet::ParseError, "regsubst(): bad flag `#{f}'")
             end
         end
-        re = Regexp.compile(regexp, reflags, lang)
-        if global
-            result = str.gsub(re, replacement)
+        begin
+            re = Regexp.compile(regexp, reflags, lang)
+        rescue RegexpError, TypeError
+            raise(Puppet::ParseError,
+                  "regsubst(): Bad regular expression `#{regexp}'")
+        end
+        if target.respond_to?(operation)
+            # String parameter -> string result
+            result = target.send(operation, re, replacement)
+        elsif target.respond_to?(:collect) and
+                target.respond_to?(:all?) and
+                target.all? { |e| e.respond_to?(operation) }
+            # Array parameter -> array result
+            result = target.collect { |e|
+                e.send(operation, re, replacement)
+            }
         else
-            result = str.sub(re, replacement)
+            raise(Puppet::ParseError,
+                  "regsubst(): bad target #{target.class}:`#{target}'")
         end
         return result
     end

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

@@ -23,12 +23,27 @@ class depends on the required class.
        file { '/foo': notify => Service[foo] }
     }
 
+Note that this function only works with clients 0.25 and later, and it will
+fail if used with earlier clients.
+
 ") do |vals|
-        send(:function_include, vals)
+    # Verify that the 'include' function is loaded
+    method = Puppet::Parser::Functions.function(:include)
+
+    send(method, vals)
+    if resource.metaparam_compatibility_mode?
+        warning "The 'require' function is only compatible with clients at 0.25 and above; including class but not adding dependency"
+    else
         vals = [vals] unless vals.is_a?(Array)
 
-        # add a relation from ourselves to each required klass
         vals.each do |klass|
-            compiler.catalog.add_edge(resource, findresource(:class, klass))
+            # This is a bit hackish, in some ways, but it's the only way
+            # to configure a dependency that will make it to the client.
+            # The 'obvious' way is just to add an edge in the catalog,
+            # but that is considered a containment edge, not a dependency
+            # edge, so it usually gets lost on the client.
+            ref = Puppet::Parser::Resource::Reference.new(:type => :class, :title => klass)
+            resource.set_parameter(:require, ref)
         end
+    end
 end

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

@@ -18,7 +18,7 @@ This functions returns a number::
 Example::
 
     if versioncmp('2.6-1', '2.4.5') > 0 {
-        notify('2.6-1 is > than 2.4.5')
+        notice('2.6-1 is > than 2.4.5')
     }
 
 ") do |args|

data/lib/puppet/parser/interpreter.rb

@@ -62,7 +62,7 @@ class Puppet::Parser::Interpreter
     def create_parser(environment)
         begin
             parser = Puppet::Parser::Parser.new(:environment => environment)
-            if code = Puppet.settings.value(:code, environment) and code != ""
+            if code = Puppet.settings.uninterpolated_value(:code, environment) and code != ""
                 parser.string = code
             else
                 file = Puppet.settings.value(:manifest, environment)

data/lib/puppet/parser/lexer.rb

@@ -11,7 +11,7 @@ end
 module Puppet::Parser; end
 
 class Puppet::Parser::Lexer
-    attr_reader :last, :file
+    attr_reader :last, :file, :lexing_context
 
     attr_accessor :line, :indefine
 
@@ -41,6 +41,11 @@ class Puppet::Parser::Lexer
                 @name.to_s
             end
         end
+        
+        def acceptable?(context={})
+            # By default tokens are aceeptable in any context
+            true 
+        end
     end
 
     # Maintain a list of tokens.
@@ -171,7 +176,7 @@ class Puppet::Parser::Lexer
         [self,value]
     end
 
-    TOKENS.add_token :REGEX, %r{/[^/]*/} do |lexer, value|
+    regex_token = TOKENS.add_token :REGEX, %r{/[^/\n]*/} do |lexer, value|
         # Make sure we haven't matched an escaped /
         while value[-2..-2] == '\\'
             other = lexer.scan_until(%r{/})
@@ -181,6 +186,10 @@ class Puppet::Parser::Lexer
         [self, Regexp.new(regex)]
     end
 
+    def regex_token.acceptable?(context={})
+        [:NODE,:LBRACE,:RBRACE,:MATCH,:NOMATCH,:COMMA].include? context[:after]
+    end
+
     TOKENS.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true
 
     TOKENS.add_token :SQUOTE, "'" do |lexer, value|
@@ -286,36 +295,28 @@ class Puppet::Parser::Lexer
     # Find the next token that matches a regex.  We look for these first.
     def find_regex_token
         @regex += 1
-        matched_token = nil
-        value = ""
-        length = 0
+        best_token = nil
+        best_length = 0
 
         # I tried optimizing based on the first char, but it had
         # a slightly negative affect and was a good bit more complicated.
         TOKENS.regex_tokens.each do |token|
-            next unless match_length = @scanner.match?(token.regex)
-
-            # We've found a longer match
-            if match_length > length
-                value = @scanner.scan(token.regex)
-                length = value.length
-                matched_token = token
+            if length = @scanner.match?(token.regex) and token.acceptable?(lexing_context)
+                # We've found a longer match
+                if length > best_length
+                    best_length = length
+                    best_token = token
+                end
             end
         end
 
-        return matched_token, value
+        return best_token, @scanner.scan(best_token.regex) if best_token
     end
 
     # Find the next token, returning the string and the token.
     def find_token
         @find += 1
-        matched_token, value = find_regex_token
-
-        unless matched_token
-            matched_token, value = find_string_token
-        end
-
-        return matched_token, value
+        find_regex_token || find_string_token
     end
 
     def indefine?
@@ -345,6 +346,7 @@ class Puppet::Parser::Lexer
         @indefine = false
         @expected = []
         @commentstack = [ ['', @line] ]
+        @lexing_context = {:after => nil, :start_of_line => true}
     end
 
     # Make any necessary changes to the token and/or value.
@@ -417,17 +419,11 @@ class Puppet::Parser::Lexer
                 raise "Could not match '%s'" % nword
             end
 
-            if matched_token.name == :RETURN
-                # this matches a blank line
-                if @last_return
-                    # eat the previously accumulated comments
-                    getcomment
-                end
-                # since :RETURN skips, we won't survive to munge_token
-                @last_return = true
-            else
-                @last_return = false
-            end
+            newline = matched_token.name == :RETURN
+
+            # this matches a blank line; eat the previously accumulated comments
+            getcomment if lexing_context[:start_of_line] and newline
+            lexing_context[:start_of_line] = newline
 
             final_token, token_value = munge_token(matched_token, value)
 
@@ -436,6 +432,8 @@ class Puppet::Parser::Lexer
                 next
             end
 
+            lexing_context[:after]         = final_token.name unless newline
+
             value = token_value[:value]
 
             if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE