puppet 0.24.9 → 0.25.0

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

@@ -0,0 +1,31 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    class MatchOperator < AST::Branch
+
+        attr_accessor :lval, :rval, :operator
+
+        # Iterate across all of our children.
+        def each
+            [@lval,@rval].each { |child| yield child }
+        end
+
+        # Returns a boolean which is the result of the boolean operation
+        # of lval and rval operands
+        def evaluate(scope)
+            lval = @lval.safeevaluate(scope)
+
+            return @operator == "=~" if rval.evaluate_match(lval, scope)
+            return @operator == "!~"
+        end
+
+        def initialize(hash)
+            super
+
+            unless %w{!~ =~}.include?(@operator)
+                raise ArgumentError, "Invalid regexp operator %s" % @operator
+            end
+        end
+    end
+end

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

@@ -11,17 +11,21 @@ class Puppet::Parser::AST::Node < Puppet::Parser::AST::HostClass
     def initialize(options)
         @parentclass = nil
         super
-
-        # Do some validation on the node name
-        if @name =~ /[^-\w.]/
-            raise Puppet::ParseError, "Invalid node name %s" % @name
-        end
     end
 
     def namespace
         ""
     end
 
+    # in Regex mode, our classname can't be our Regex.
+    # so we use the currently connected client as our
+    # classname, mimicing exactly what would have happened
+    # if there was a specific node definition for this node.
+    def get_classname(scope)
+        return scope.host if name.regex?
+        classname
+    end
+
     # Make sure node scopes are marked as such.
     def subscope(*args)
         scope = super
@@ -33,6 +37,6 @@ class Puppet::Parser::AST::Node < Puppet::Parser::AST::HostClass
 
     # Search for the object matching our parent class.
     def find_parentclass
-        @parser.findnode(parentclass)
+        @parser.node(parentclass)
     end
 end

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

@@ -2,7 +2,7 @@ require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
     # A statement syntactically similar to an ResourceDef, but uses a
-    # capitalized object type and cannot have a name.  
+    # capitalized object type and cannot have a name.
     class ResourceDefaults < AST::Branch
         attr_accessor :type, :params
 
@@ -12,7 +12,7 @@ class Puppet::Parser::AST
         # object type.
         def evaluate(scope)
             # Use a resource reference to canonize the type
-            ref = Puppet::ResourceReference.new(@type, "whatever")
+            ref = Puppet::Resource::Reference.new(@type, "whatever")
             type = ref.type
             params = @params.safeevaluate(scope)
 

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

@@ -34,7 +34,7 @@ class Puppet::Parser::AST
             # Now we just create a normal resource, but we call a very different
             # method on the scope.
             resource = [resource] unless resource.is_a?(Array)
-            
+
             resource = resource.collect do |r|
                 res = Puppet::Parser::Resource.new(
                     :type => r.type,

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

@@ -25,7 +25,7 @@ class Puppet::Parser::AST
         def evaluate(scope)
             title = @title.safeevaluate(scope)
             title = [title] unless title.is_a?(Array)
-            
+
             if @type.to_s.downcase == "class"
                 resource_type = "class"
                 title = title.collect { |t| qualified_class(scope, t) }
@@ -43,7 +43,7 @@ class Puppet::Parser::AST
         # Look up a fully qualified class name.
         def qualified_class(scope, title)
             # Look up the full path to the class
-            if classobj = scope.findclass(title)
+            if classobj = scope.find_hostclass(title)
                 title = classobj.classname
             else
                 raise Puppet::ParseError, "Could not find class %s" % title
@@ -56,7 +56,7 @@ class Puppet::Parser::AST
             # We want a lower-case type.  For some reason.
             objtype = @type.downcase
             unless builtintype?(objtype)
-                if dtype = scope.finddefine(objtype)
+                if dtype = scope.find_definition(objtype)
                     objtype = dtype.classname
                 else
                     raise Puppet::ParseError, "Could not find resource type %s" % objtype
@@ -64,5 +64,13 @@ class Puppet::Parser::AST
             end
             return objtype
         end
+
+        def to_s
+            if title.is_a?(ASTArray)
+                "#{type.to_s.capitalize}#{title}"
+            else
+                "#{type.to_s.capitalize}[#{title}]"
+            end
+        end
     end
 end

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

@@ -12,17 +12,12 @@ class Puppet::Parser::AST
 
         # Find the value that corresponds with the test.
         def evaluate(scope)
-            retvalue = nil
-            found = nil
-
             # Get our parameter.
             paramvalue = @param.safeevaluate(scope)
-            
+
             sensitive = Puppet[:casesensitive]
-            
-            if ! sensitive and paramvalue.respond_to?(:downcase)
-                paramvalue = paramvalue.downcase
-            end
+
+            paramvalue = paramvalue.downcase if not sensitive and paramvalue.respond_to?(:downcase)
 
             default = nil
 
@@ -31,33 +26,20 @@ class Puppet::Parser::AST
             end
 
             # Then look for a match in the options.
-            @values.each { |obj|
-                param = obj.param.safeevaluate(scope)
-                if ! sensitive && param.respond_to?(:downcase)
-                    param = param.downcase
-                end
-                if param == paramvalue
-                    # we found a matching option
-                    retvalue = obj.value.safeevaluate(scope)
-                    found = true
-                    break
-                elsif obj.param.is_a?(Default)
-                    # Store the default, in case it's necessary.
-                    default = obj
-                end
-            }
+            @values.each do |obj|
+                # short circuit asap if we have a match
+                return obj.value.safeevaluate(scope) if obj.param.evaluate_match(paramvalue, scope, :file => file, :line => line, :sensitive => sensitive)
 
-            # Unless we found something, look for the default.
-            unless found
-                if default
-                    retvalue = default.value.safeevaluate(scope)
-                else
-                    self.fail Puppet::ParseError,
-                        "No matching value for selector param '%s'" % paramvalue
-                end
+                # Store the default, in case it's necessary.
+                default = obj if obj.param.is_a?(Default)
             end
 
-            return retvalue
+            # Unless we found something, look for the default.
+            return default.value.safeevaluate(scope) if default
+
+            self.fail Puppet::ParseError, "No matching value for selector param '%s'" % paramvalue
+        ensure
+            scope.unset_ephemeral_var
         end
     end
 end

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

@@ -17,7 +17,7 @@ class Puppet::Parser::AST
             value = @value.safeevaluate(scope)
 
             parsewrap do
-                scope.setvar(name,value, @file, @line, @append)
+                scope.setvar(name,value, :file => @file, :line => @line, :append => @append)
             end
         end
 

data/lib/puppet/parser/collector.rb

@@ -1,10 +1,12 @@
 # An object that collects stored objects from the central cache and returns
 # them to the current host, yo.
 class Puppet::Parser::Collector
-    attr_accessor :type, :scope, :vquery, :equery, :form, :resources
+    attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
 
     # Call the collection method, mark all of the returned objects as non-virtual,
-    # and then delete this object from the list of collections to evaluate.
+    # optionally applying parameter overrides. The collector can also delete himself
+    # from the compiler if there is no more resources to collect (valid only for resource fixed-set collector
+    # which get their resources from +collect_resources+ and not from the catalog)
     def evaluate
         # Shortcut if we're not using storeconfigs and they're trying to collect
         # exported resources.
@@ -12,10 +14,9 @@ class Puppet::Parser::Collector
             Puppet.warning "Not collecting exported resources without storeconfigs"
             return false
         end
+
         if self.resources
-            if objects = collect_resources and ! objects.empty?
-                return objects
-            else
+            unless objects = collect_resources and ! objects.empty?
                 return false
             end
         else
@@ -25,17 +26,56 @@ class Puppet::Parser::Collector
             end
             if objects.empty?
                 return false
-            else
-                return objects
             end
         end
+
+        # we have an override for the collected resources
+        if @overrides and !objects.empty?
+
+            # force the resource to be always child of any other resource
+            overrides[:source].meta_def(:child_of?) do
+                true
+            end
+
+            # tell the compiler we have some override for him unless we already
+            # overrided those resources
+            objects.each do |res|
+                unless @collected.include?(res.ref)
+                    res = Puppet::Parser::Resource.new(
+                        :type => res.type,
+                        :title => res.title,
+                        :params => overrides[:params],
+                        :file => overrides[:file],
+                        :line => overrides[:line],
+                        :source => overrides[:source],
+                        :scope => overrides[:scope]
+                    )
+
+                    scope.compiler.add_override(res)
+                end
+            end
+        end
+
+        # filter out object that already have been collected by ourself
+        objects.reject! { |o| @collected.include?(o.ref) }
+
+        return false if objects.empty?
+
+        # keep an eye on the resources we have collected
+        objects.inject(@collected) { |c,o| c[o.ref]=o; c }
+
+        # return our newly collected resources
+        objects
     end
 
     def initialize(scope, type, equery, vquery, form)
         @scope = scope
 
+        # initialisation
+        @collected = {}
+
         # Canonize the type
-        @type = Puppet::ResourceReference.new(type, "whatever").type
+        @type = Puppet::Resource::Reference.new(type, "whatever").type
         @equery = equery
         @vquery = vquery
 
@@ -43,6 +83,16 @@ class Puppet::Parser::Collector
         @form = form
     end
 
+    # add a resource override to the soon to be exported/realized resources
+    def add_override(hash)
+        unless hash[:params]
+            raise ArgumentError, "Exported resource try to override without parameters"
+        end
+
+        # schedule an override for an upcoming collection
+        @overrides = hash
+    end
+
     private
 
     # Create our active record query.
@@ -59,6 +109,13 @@ class Puppet::Parser::Collector
 
         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
+        end
+
         # We're going to collect objects from rails, but we don't want any
         # objects from this host.
         search = ("host_id != ? AND %s" % search) and values.unshift(host.id) if host
@@ -132,13 +189,8 @@ class Puppet::Parser::Collector
 
     # Collect just virtual objects, from our local compiler.
     def collect_virtual(exported = false)
-        if exported
-            method = :exported?
-        else
-            method = :virtual?
-        end
         scope.compiler.resources.find_all do |resource|
-            resource.type == @type and resource.send(method) and match?(resource)
+            resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
         end
     end
 
@@ -155,7 +207,7 @@ class Puppet::Parser::Collector
         resource = obj.to_resource(self.scope)
 
         resource.exported = false
-        
+
         scope.compiler.add_resource(scope, resource)
 
         return resource

data/lib/puppet/parser/compiler.rb

@@ -2,7 +2,7 @@
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet/node'
-require 'puppet/node/catalog'
+require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 # Maintain a graph of scopes, along with a bunch of data
@@ -10,7 +10,7 @@ require 'puppet/util/errors'
 class Puppet::Parser::Compiler
     include Puppet::Util
     include Puppet::Util::Errors
-    attr_reader :parser, :node, :facts, :collections, :catalog, :node_scope
+    attr_reader :parser, :node, :facts, :collections, :catalog, :node_scope, :resources
 
     # Add a collection to the global list.
     def add_collection(coll)
@@ -31,18 +31,24 @@ class Puppet::Parser::Compiler
 
     # Store a resource in our resource table.
     def add_resource(scope, resource)
+        @resources << resource
+
         # Note that this will fail if the resource is not unique.
         @catalog.add_resource(resource)
 
         # And in the resource graph.  At some point, this might supercede
         # the global resource table, but the table is a lot faster
         # so it makes sense to maintain for now.
-        @catalog.add_edge(scope.resource, resource)
+        if resource.type.to_s.downcase == "class" and main = @catalog.resource(:class, :main)
+            @catalog.add_edge(main, resource)
+        else
+            @catalog.add_edge(scope.resource, resource)
+        end
     end
 
     # Do we use nodes found in the code, vs. the external node sources?
     def ast_nodes?
-        parser.nodes.length > 0
+        parser.nodes?
     end
 
     # Store the fact that we've evaluated a class, and store a reference to
@@ -95,10 +101,6 @@ class Puppet::Parser::Compiler
 
         fail_on_unevaluated()
 
-        if Puppet[:storeconfigs]
-            store()
-        end
-
         return @catalog
     end
 
@@ -135,7 +137,7 @@ class Puppet::Parser::Compiler
         found = []
         classes.each do |name|
             # If we can find the class, then make a resource that will evaluate it.
-            if klass = scope.findclass(name)
+            if klass = scope.find_hostclass(name)
                 found << name and next if class_scope(klass)
 
                 resource = klass.evaluate(scope)
@@ -204,11 +206,6 @@ class Puppet::Parser::Compiler
         @resource_overrides[resource.ref]
     end
 
-    # Return a list of all resources.
-    def resources
-        @catalog.vertices
-    end
-
     # The top scope is usually the top-level scope, but if we're using AST nodes,
     # then it is instead the node's scope.
     def topscope
@@ -224,10 +221,10 @@ class Puppet::Parser::Compiler
         # Now see if we can find the node.
         astnode = nil
         @node.names.each do |name|
-            break if astnode = @parser.nodes[name.to_s.downcase]
+            break if astnode = @parser.node(name.to_s.downcase)
         end
 
-        unless (astnode ||= @parser.nodes["default"])
+        unless (astnode ||= @parser.node("default"))
             raise Puppet::ParseError, "Could not find default node or by name with '%s'" % node.names.join(", ")
         end
 
@@ -305,11 +302,12 @@ class Puppet::Parser::Compiler
 
     # Find and evaluate our main object, if possible.
     def evaluate_main
-        @main = @parser.findclass("", "") || @parser.newclass("")
+        @main = @parser.find_hostclass("", "") || @parser.newclass("")
         @topscope.source = @main
         @main_resource = Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => @topscope, :source => @main)
         @topscope.resource = @main_resource
 
+        @resources << @main_resource
         @catalog.add_resource(@main_resource)
 
         @main_resource.evaluate
@@ -366,7 +364,7 @@ class Puppet::Parser::Compiler
     # Make sure all of our resources and such have done any last work
     # necessary.
     def finish
-        @catalog.vertices.each do |resource|
+        resources.each do |resource|
             # Add in any resource overrides.
             if overrides = resource_overrides(resource)
                 overrides.each do |over|
@@ -412,8 +410,11 @@ class Puppet::Parser::Compiler
         @scope_graph = Puppet::SimpleGraph.new
 
         # For maintaining the relationship between scopes and their resources.
-        @catalog = Puppet::Node::Catalog.new(@node.name)
+        @catalog = Puppet::Resource::Catalog.new(@node.name)
         @catalog.version = @parser.version
+
+        # local resource array to maintain resource ordering
+        @resources = []
     end
 
     # Set the node's parameters into the top-scope as variables.
@@ -423,43 +424,10 @@ class Puppet::Parser::Compiler
         end
     end
 
-    # Store the catalog into the database.
-    def store
-        unless Puppet.features.rails?
-            raise Puppet::Error,
-                "storeconfigs is enabled but rails is unavailable"
-        end
-
-        unless ActiveRecord::Base.connected?
-            Puppet::Rails.connect
-        end
-
-        # We used to have hooks here for forking and saving, but I don't
-        # think it's worth retaining at this point.
-        store_to_active_record(@node, @catalog.vertices)
-    end
-
-    # Do the actual storage.
-    def store_to_active_record(node, resources)
-        begin
-            # We store all of the objects, even the collectable ones
-            benchmark(:info, "Stored catalog for #{node.name}") do
-                Puppet::Rails::Host.transaction do
-                    Puppet::Rails::Host.store(node, resources)
-                end
-            end
-        rescue => detail
-            if Puppet[:trace]
-                puts detail.backtrace
-            end
-            Puppet.err "Could not store configs: %s" % detail.to_s
-        end
-    end
-
     # Return an array of all of the unevaluated resources.  These will be definitions,
     # which need to get evaluated into native resources.
     def unevaluated_resources
-        ary = @catalog.vertices.reject { |resource| resource.builtin? or resource.evaluated?  }
+        ary = resources.reject { |resource| resource.builtin? or resource.evaluated?  }
 
         if ary.empty?
             return nil