puppet 0.25.0 → 0.25.1

data/lib/puppet/external/pson/pure/parser.rb

@@ -0,0 +1,269 @@
+require 'strscan'
+
+module PSON
+  module Pure
+    # This class implements the PSON parser that is used to parse a PSON string
+    # into a Ruby data structure.
+    class Parser < StringScanner
+      STRING                = /" ((?:[^\x0-\x1f"\\] |
+                                   # escaped special characters:
+                                  \\["\\\/bfnrt] |
+                                  \\u[0-9a-fA-F]{4} |
+                                   # match all but escaped special characters:
+                                  \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
+                              "/nx
+      INTEGER               = /(-?0|-?[1-9]\d*)/
+      FLOAT                 = /(-?
+                                (?:0|[1-9]\d*)
+                                (?:
+                                  \.\d+(?i:e[+-]?\d+) |
+                                  \.\d+ |
+                                  (?i:e[+-]?\d+)
+                                )
+                                )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
+      OBJECT_OPEN           = /\{/
+      OBJECT_CLOSE          = /\}/
+      ARRAY_OPEN            = /\[/
+      ARRAY_CLOSE           = /\]/
+      PAIR_DELIMITER        = /:/
+      COLLECTION_DELIMITER  = /,/
+      TRUE                  = /true/
+      FALSE                 = /false/
+      NULL                  = /null/
+      IGNORE                = %r(
+        (?:
+         //[^\n\r]*[\n\r]| # line comments
+         /\*               # c-style comments
+         (?:
+          [^*/]|        # normal chars
+          /[^*]|        # slashes that do not start a nested comment
+          \*[^/]|       # asterisks that do not end this comment
+          /(?=\*/)      # single slash before this comment's end 
+         )*
+           \*/               # the End of this comment
+           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        )+
+      )mx
+
+      UNPARSED = Object.new
+
+      # Creates a new PSON::Pure::Parser instance for the string _source_.
+      #
+      # It will be configured by the _opts_ hash. _opts_ can have the following
+      # keys:
+      # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+      #   structures. Disable depth checking with :max_nesting => false|nil|0,
+      #   it defaults to 19.
+      # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+      #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+      #   to false.
+      # * *create_additions*: If set to false, the Parser doesn't create
+      #   additions even if a matchin class and create_id was found. This option
+      #   defaults to true.
+      # * *object_class*: Defaults to Hash
+      # * *array_class*: Defaults to Array
+      def initialize(source, opts = {})
+        super
+        if !opts.key?(:max_nesting) # defaults to 19
+          @max_nesting = 19
+        elsif opts[:max_nesting]
+          @max_nesting = opts[:max_nesting]
+        else
+          @max_nesting = 0
+        end
+        @allow_nan = !!opts[:allow_nan]
+        ca = true
+        ca = opts[:create_additions] if opts.key?(:create_additions)
+        @create_id = ca ? PSON.create_id : nil
+        @object_class = opts[:object_class] || Hash
+        @array_class = opts[:array_class] || Array
+      end
+
+      alias source string
+
+      # Parses the current PSON string _source_ and returns the complete data
+      # structure as a result.
+      def parse
+        reset
+        obj = nil
+        until eos?
+          case
+          when scan(OBJECT_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in PSON!"
+            @current_nesting = 1
+            obj = parse_object
+          when scan(ARRAY_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in PSON!"
+            @current_nesting = 1
+            obj = parse_array
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "source '#{peek(20)}' not in PSON!"
+          end
+        end
+        obj or raise ParserError, "source did not contain any PSON!"
+        obj
+      end
+
+      private
+
+      # Unescape characters in strings.
+      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+      UNESCAPE_MAP.update({
+        ?"  => '"',
+        ?\\ => '\\',
+        ?/  => '/',
+        ?b  => "\b",
+        ?f  => "\f",
+        ?n  => "\n",
+        ?r  => "\r",
+        ?t  => "\t",
+        ?u  => nil, 
+      })
+
+      def parse_string
+        if scan(STRING)
+          return '' if self[1].empty?
+          string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+            if u = UNESCAPE_MAP[$&[1]]
+              u
+            else # \uXXXX
+              bytes = ''
+              i = 0
+              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+                bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+                i += 1
+              end
+              PSON::UTF16toUTF8.iconv(bytes)
+            end
+          end
+          if string.respond_to?(:force_encoding)
+            string.force_encoding(Encoding::UTF_8)
+          end
+          string
+        else
+          UNPARSED
+        end
+      rescue Iconv::Failure => e
+        raise GeneratorError, "Caught #{e.class}: #{e}"
+      end
+
+      def parse_value
+        case
+        when scan(FLOAT)
+          Float(self[1])
+        when scan(INTEGER)
+          Integer(self[1])
+        when scan(TRUE)
+          true
+        when scan(FALSE)
+          false
+        when scan(NULL)
+          nil
+        when (string = parse_string) != UNPARSED
+          string
+        when scan(ARRAY_OPEN)
+          @current_nesting += 1
+          ary = parse_array
+          @current_nesting -= 1
+          ary
+        when scan(OBJECT_OPEN)
+          @current_nesting += 1
+          obj = parse_object
+          @current_nesting -= 1
+          obj
+        when @allow_nan && scan(NAN)
+          NaN
+        when @allow_nan && scan(INFINITY)
+          Infinity
+        when @allow_nan && scan(MINUS_INFINITY)
+          MinusInfinity
+        else
+          UNPARSED
+        end
+      end
+
+      def parse_array
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @array_class.new
+        delim = false
+        until eos?
+          case
+          when (value = parse_value) != UNPARSED
+            delim = false
+            result << value
+            skip(IGNORE)
+            if scan(COLLECTION_DELIMITER)
+              delim = true
+            elsif match?(ARRAY_CLOSE)
+              ;
+            else
+              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+            end
+          when scan(ARRAY_CLOSE)
+            if delim
+              raise ParserError, "expected next element in array at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+
+      def parse_object
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @object_class.new
+        delim = false
+        until eos?
+          case
+          when (string = parse_string) != UNPARSED
+            skip(IGNORE)
+            unless scan(PAIR_DELIMITER)
+              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+            end
+            skip(IGNORE)
+            unless (value = parse_value).equal? UNPARSED
+              result[string] = value
+              delim = false
+              skip(IGNORE)
+              if scan(COLLECTION_DELIMITER)
+                delim = true
+              elsif match?(OBJECT_CLOSE)
+                ;
+              else
+                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+              end
+            else
+              raise ParserError, "expected value in object at '#{peek(20)}'!"
+            end
+          when scan(OBJECT_CLOSE)
+            if delim
+              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+            end
+            if @create_id and klassname = result[@create_id]
+              klass = PSON.deep_const_get klassname
+              break unless klass and klass.pson_creatable?
+              result = klass.pson_create(result)
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/puppet/external/pson/version.rb

@@ -0,0 +1,8 @@
+module PSON
+  # PSON version
+  VERSION         = '1.1.9'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/puppet/feature/pson.rb

@@ -0,0 +1,6 @@
+Puppet.features.add(:pson) do
+    require 'puppet/external/pson/common'
+    require 'puppet/external/pson/version'
+    require 'puppet/external/pson/pure'
+    true
+end

data/lib/puppet/feature/rails.rb

@@ -8,6 +8,7 @@ Puppet.features.rubygems?
 Puppet.features.add(:rails) do
     begin
         require 'active_record'
+        require 'active_record/version'
     rescue LoadError => detail
         if FileTest.exists?("/usr/share/rails")
             count = 0
@@ -34,8 +35,3 @@ Puppet.features.add(:rails) do
         true
     end
 end
-
-# We have JSON available
-# This is stupid - Rails breaks json compatibility if we load json before
-# rails, therefore we load rails and then json.  Dumb, mother-dumb.
-Puppet.features.add(:json, :libs => ["json"])

data/lib/puppet/file_serving/configuration.rb

@@ -96,9 +96,9 @@ class Puppet::FileServing::Configuration
 
     def mk_default_mounts
         @mounts["modules"] ||= Mount::Modules.new("modules")
-        @mounts["modules"].allow('*')
+        @mounts["modules"].allow('*') if @mounts["modules"].empty?
         @mounts["plugins"] ||= Mount::Plugins.new("plugins")
-        @mounts["plugins"].allow('*')
+        @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
     end
 
     # Read the configuration file.

data/lib/puppet/indirector/certificate/rest.rb

@@ -6,4 +6,10 @@ class Puppet::SSL::Certificate::Rest < Puppet::Indirector::REST
 
     use_server_setting(:ca_server)
     use_port_setting(:ca_port)
+
+    def find(request)
+        return nil unless result = super
+        result.name = request.key unless result.name == request.key
+        result
+    end
 end

data/lib/puppet/indirector/facts/facter.rb

@@ -29,7 +29,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
                     Timeout::timeout(self.timeout) do
                         load file
                     end
-                rescue => detail
+                rescue Exception => detail
                     Puppet.warning "Could not load fact file %s: %s" % [fqfile, detail]
                 end
             end

data/lib/puppet/indirector/ldap.rb

@@ -40,7 +40,7 @@ class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
                 found = true
                 yield entry
             end
-        rescue => detail
+        rescue Exception => detail
             if count == 0
                 # Try reconnecting to ldap if we get an exception and we haven't yet retried.
                 count += 1

data/lib/puppet/indirector/queue.rb

@@ -24,7 +24,7 @@ class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
 
     def initialize(*args)
         super
-        raise ArgumentError, "Queueing requires json support" unless Puppet.features.json?
+        raise ArgumentError, "Queueing requires pson support" unless Puppet.features.pson?
     end
 
     # Queue has no idiomatic "find"
@@ -37,7 +37,7 @@ class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
         begin
             result = nil
             benchmark :info, "Queued %s for %s" % [indirection.name, request.key] do
-                result = client.send_message(queue, request.instance.render(:json))
+                result = client.send_message(queue, request.instance.render(:pson))
             end
             result
         rescue => detail
@@ -62,7 +62,7 @@ class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
     def self.intern(message)
         result = nil
         benchmark :info, "Loaded queued %s" % [indirection.name] do
-            result = model.convert_from(:json, message)
+            result = model.convert_from(:pson, message)
         end
         result
     end

data/lib/puppet/indirector/rest.rb

@@ -51,7 +51,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
             end
         else
             # Raise the http error if we didn't get a 'success' of some kind.
-            message = "Error %s on SERVER: %s" % [response.code, response.message]
+            message = "Error %s on SERVER: %s" % [response.code, (response.body||'').empty? ? response.message : response.body]
             raise Net::HTTPError.new(message, response)
         end
     end

data/lib/puppet/network/authstore.rb

@@ -63,6 +63,11 @@ module Puppet
             @globalallow
         end
 
+        # does this auth store has any rules?
+        def empty?
+            @globalallow.nil? && @declarations.size == 0
+        end
+
         def initialize
             @globalallow = nil
             @declarations = []
@@ -220,8 +225,6 @@ module Puppet
             # and we're called with a MatchData whose capture 1 is puppet
             # we'll return a pattern of puppet.reductivelabs.com
             def interpolate(match)
-                return self if @name == :ip
-
                 clone = dup
                 clone.pattern = clone.pattern.reverse.collect do |p|
                     p.gsub(/\$(\d)/) { |m| match[$1.to_i] }
@@ -279,63 +282,41 @@ module Puppet
             # Parse our input pattern and figure out what kind of allowal
             # statement it is.  The output of this is used for later matching.
             def parse(value)
-                case value
-                when /^(\d+\.){1,3}\*$/ # an ip address with a '*' at the end
+                # Use the IPAddr class to determine if we've got a
+                # valid IP address.
+                @length = Integer($1) if value =~ /\/(\d+)$/
+                begin
+                    @pattern = IPAddr.new(value)
                     @name = :ip
-                    match = $1
-                    match.sub!(".", '')
-                    ary = value.split(".")
-
-                    mask = case ary.index(match)
-                    when 0; 8
-                    when 1; 16
-                    when 2; 24
-                    else
-                        raise AuthStoreError, "Invalid IP pattern %s" % value
-                    end
-
-                    @length = mask
-
-                    ary.pop
-                    while ary.length < 4
-                        ary.push("0")
-                    end
-
-                    begin
-                        @pattern = IPAddr.new(ary.join(".") + "/" + mask.to_s)
-                    rescue ArgumentError => detail
-                        raise AuthStoreError, "Invalid IP address pattern %s" % value
-                    end
-                when /^([a-zA-Z][-\w]*\.)+[-\w]+$/ # a full hostname
-                    # Change to /^([a-zA-Z][-\w]*\.)+[-\w]+\.?$/ for FQDN support
-                    @name = :domain
-                    @pattern = munge_name(value)
-                when /^\*(\.([a-zA-Z][-\w]*)){1,}$/ # *.domain.com
-                    @name = :domain
-                    @pattern = munge_name(value)
-                    @pattern.pop # take off the '*'
-                    @length = @pattern.length
-                when /\$\d+/ # a backreference pattern ala $1.reductivelabs.com or 192.168.0.$1 or $1.$2
-                    @name = :dynamic
-                    @pattern = munge_name(value)
-                else
-                    # Else, use the IPAddr class to determine if we've got a
-                    # valid IP address.
-                    if value =~ /\/(\d+)$/
-                        @length = Integer($1)
-                    end
-                    begin
-                        @pattern = IPAddr.new(value)
+                rescue ArgumentError => detail
+                    case value
+                    when /^(\d+\.){1,3}\*$/ # an ip address with a '*' at the end
                         @name = :ip
-                    rescue ArgumentError => detail
-                        # so nothing matched, let's match as an opaque value
-                        # some sanity checks first
-                        unless value =~ /^[a-zA-Z0-9][-a-zA-Z0-9_.@]*$/
-                            raise AuthStoreError, "Invalid pattern %s" % value
+                        segments = value.split(".")[0..-2]
+                        @length = 8*segments.length
+                        begin
+                            @pattern = IPAddr.new((segments+[0,0,0])[0,4].join(".") + "/" + @length.to_s)
+                        rescue ArgumentError => detail
+                            raise AuthStoreError, "Invalid IP address pattern %s" % value
                         end
+                    when /^([a-zA-Z0-9][-\w]*\.)+[-\w]+$/ # a full hostname
+                        # Change to /^([a-zA-Z][-\w]*\.)+[-\w]+\.?$/ for FQDN support
+                        @name = :domain
+                        @pattern = munge_name(value)
+                    when /^\*(\.([a-zA-Z][-\w]*)){1,}$/ # *.domain.com
+                        @name = :domain
+                        @pattern = munge_name(value)
+                        @pattern.pop # take off the '*'
+                        @length = @pattern.length
+                    when /\$\d+/ # a backreference pattern ala $1.reductivelabs.com or 192.168.0.$1 or $1.$2
+                        @name = :dynamic
+                        @pattern = munge_name(value)
+                    when /^[a-zA-Z0-9][-a-zA-Z0-9_.@]*$/
                         @pattern = [value]
                         @length = nil # force an exact match
                         @name = :opaque
+                    else
+                        raise AuthStoreError, "Invalid pattern %s" % value
                     end
                 end
             end