puppet 0.24.9 → 0.25.0

data/lib/puppet/parser/parser_support.rb

@@ -2,16 +2,9 @@
 # tired of rebuilding the parser.rb file all the time.
 class Puppet::Parser::Parser
     require 'puppet/parser/functions'
-
-    ASTSet = Struct.new(:classes, :definitions, :nodes)
-
-    # Define an accessor method for each table.  We hide the existence of
-    # the struct.
-    [:classes, :definitions, :nodes].each do |name|
-        define_method(name) do
-            @astset.send(name)
-        end
-    end
+    require 'puppet/parser/files'
+    require 'puppet/parser/loaded_code'
+    require 'monitor'
 
     AST = Puppet::Parser::AST
 
@@ -58,7 +51,7 @@ class Puppet::Parser::Parser
         end
 
         k = klass.new(hash)
-        k.doc = lexer.getcomment if !k.nil? and k.use_docs and k.doc.empty?
+        k.doc = lexer.getcomment(hash[:line]) if !k.nil? and k.use_docs and k.doc.empty?
         return k
     end
 
@@ -105,56 +98,45 @@ class Puppet::Parser::Parser
         end
     end
 
-    # Find a class definition, relative to the current namespace.
-    def findclass(namespace, name)
-        fqfind namespace, name, classes
+    [:hostclass, :definition, :node, :nodes?].each do |method|
+        define_method(method) do |*args|
+            @loaded_code.send(method, *args)
+        end
     end
 
-    # Find a component definition, relative to the current namespace.
-    def finddefine(namespace, name)
-        fqfind namespace, name, definitions
+    def find_hostclass(namespace, name)
+        find_or_load(namespace, name, :hostclass)
     end
 
-    # This is only used when nodes are looking up the code for their
-    # parent nodes.
-    def findnode(name)
-        fqfind "", name, nodes
+    def find_definition(namespace, name)
+        find_or_load(namespace, name, :definition)
     end
 
-    # The recursive method used to actually look these objects up.
-    def fqfind(namespace, name, table)
+    def find_or_load(namespace, name, type)
+        method = "find_#{type}"
         namespace = namespace.downcase
-        name = name.to_s.downcase
+        name      = name.downcase
+        fullname = (namespace + "::" + name).sub(/^::/, '')
 
-        # If our classname is fully qualified or we have no namespace,
-        # just try directly for the class, and return either way.
-        if name =~ /^::/ or namespace == ""
-            classname = name.sub(/^::/, '')
-            self.load(classname) unless table[classname]
-            return table[classname]
-        end
-
-        # Else, build our namespace up piece by piece, checking
-        # for the class in each namespace.
-        ary = namespace.split("::")
+        if name =~ /^::/
+            names_to_try = [name.sub(/^::/, '')]
+        else
+            names_to_try = [fullname]
 
-        while ary.length > 0
-            newname = (ary + [name]).join("::").sub(/^::/, '')
-            if obj = table[newname] or (self.load(newname) and obj = table[newname])
-                return obj
-            end
+            # Try to load the module init file if we're a qualified name
+            names_to_try << fullname.split("::")[0] if fullname.include?("::")
 
-            # Delete the second to last object, which reduces our namespace by one.
-            ary.pop
+            # Otherwise try to load the bare name on its own.  This
+            # is appropriate if the class we're looking for is in a
+            # module that's different from our namespace.
+            names_to_try << name
+            names_to_try.compact!
         end
 
-        # If we've gotten to this point without finding it, see if the name
-        # exists at the top namespace
-        if obj = table[name] or (self.load(name) and obj = table[name])
-            return obj
+        until (result = @loaded_code.send(method, namespace, name)) or names_to_try.empty? do
+            self.load(names_to_try.shift)
         end
-
-        return nil
+        return result
     end
 
     # Import our files.
@@ -175,6 +157,7 @@ class Puppet::Parser::Parser
 
         # We can't interpolate at this point since we don't have any
         # scopes set up. Warn the user if they use a variable reference
+        raise "Got no file" unless file
         pat = file
         if pat.index("$")
             Puppet.warning(
@@ -183,14 +166,14 @@ class Puppet::Parser::Parser
                "in file #{@lexer.file} at line #{@lexer.line}"
             )
         end
-        files = Puppet::Module::find_manifests(pat, :cwd => dir, :environment => @environment)
+        files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => @environment)
         if files.size == 0
             raise Puppet::ImportError.new("No file(s) found for import " +
                                           "of '#{pat}'")
         end
 
         files.collect { |file|
-            parser = Puppet::Parser::Parser.new(:astset => @astset, :environment => @environment)
+            parser = Puppet::Parser::Parser.new(:loaded_code => @loaded_code, :environment => @environment)
             parser.files = self.files
             Puppet.debug("importing '%s'" % file)
 
@@ -210,7 +193,7 @@ class Puppet::Parser::Parser
     end
 
     def initialize(options = {})
-        @astset = options[:astset] || ASTSet.new({}, {}, {})
+        @loaded_code = options[:loaded_code] || Puppet::Parser::LoadedCode.new
         @environment = options[:environment]
         initvars()
     end
@@ -220,42 +203,67 @@ class Puppet::Parser::Parser
         @lexer = Puppet::Parser::Lexer.new()
         @files = {}
         @loaded = []
-    end
-
-    # Try to load a class, since we could not find it.
-    def load(classname)
-        return false if classname == ""
-        filename = classname.gsub("::", File::SEPARATOR)
-
-        # First try to load the top-level module
-        mod = filename.scan(/^[\w-]+/).shift
-        unless @loaded.include?(mod)
-            @loaded << mod
-            begin
-                import(mod)
-                Puppet.info "Autoloaded module %s" % mod
-            rescue Puppet::ImportError => detail
-                # We couldn't load the module
+        @loading = {}
+        @loading.extend(MonitorMixin)
+        class << @loading
+            def done_with(item)
+                synchronize do 
+                    delete(item)[:busy].signal if self.has_key?(item) and self[item][:loader] == Thread.current
+                end
+            end
+            def owner_of(item)
+                synchronize do
+                    if !self.has_key? item
+                        self[item] = { :loader => Thread.current, :busy => self.new_cond}
+                        :nobody
+                      elsif self[item][:loader] == Thread.current
+                        :this_thread
+                      else
+                        flag = self[item][:busy]
+                        flag.wait
+                        flag.signal
+                        :another_thread
+                    end
+                end
             end
         end
+    end
 
-        # We don't know whether we're looking for a class or definition, so we have
-        # to test for both.
-        return true if classes.include?(classname) || definitions.include?(classname)
-
-        unless @loaded.include?(filename)
-            @loaded << filename
-            # Then the individual file
+    # Utility method factored out of load
+    def able_to_import?(classname,item,msg)
+        unless @loaded.include?(item)
             begin
-                import(filename)
-                Puppet.info "Autoloaded file %s from module %s" % [filename, mod]
+              case @loading.owner_of(item)
+              when :this_thread
+                  return
+              when :another_thread
+                  return able_to_import?(classname,item,msg)
+              when :nobody
+                  import(item)
+                  Puppet.info "Autoloaded #{msg}"
+                  @loaded << item
+              end
             rescue Puppet::ImportError => detail
-                # We couldn't load the file
+                # We couldn't load the item
+            ensure
+                @loading.done_with(item)
             end
         end
         # We don't know whether we're looking for a class or definition, so we have
         # to test for both.
-        return classes.include?(classname) || definitions.include?(classname)
+        return @loaded_code.hostclass(classname) || @loaded_code.definition(classname)
+    end
+
+    # Try to load a class, since we could not find it.
+    def load(classname)
+        return false if classname == ""
+        filename = classname.gsub("::", File::SEPARATOR)
+        mod = filename.scan(/^[\w-]+/).shift
+
+        # First try to load the top-level module then the individual file
+        [[mod,     "module %s"              %            mod ],
+         [filename,"file %s from module %s" % [filename, mod]]
+        ].any? { |item,description| able_to_import?(classname,item,description) }
     end
 
     # Split an fq name into a namespace and name
@@ -270,7 +278,7 @@ class Puppet::Parser::Parser
     def newclass(name, options = {})
         name = name.downcase
 
-        if definitions.include?(name)
+        if @loaded_code.definition(name)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" % name
         end
         code = options[:code]
@@ -278,7 +286,7 @@ class Puppet::Parser::Parser
         doc = options[:doc]
 
         # If the class is already defined, then add code to it.
-        if other = @astset.classes[name]
+        if other = @loaded_code.hostclass(name) || @loaded_code.definition(name)
             # Make sure the parents match
             if parent and other.parentclass and (parent != other.parentclass)
                 error("Class %s is already defined at %s:%s; cannot redefine" % [name, other.file, other.line])
@@ -323,22 +331,23 @@ class Puppet::Parser::Parser
             args[:code] = code if code
             args[:parentclass] = parent if parent
             args[:doc] = doc
+            args[:line] = options[:line]
 
-            @astset.classes[name] = ast AST::HostClass, args
+            @loaded_code.add_hostclass(name, ast(AST::HostClass, args))
         end
 
-        return @astset.classes[name]
+        return @loaded_code.hostclass(name)
     end
 
     # Create a new definition.
     def newdefine(name, options = {})
         name = name.downcase
-        if @astset.classes.include?(name)
+        if @loaded_code.hostclass(name)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" %
                 name
         end
         # Make sure our definition doesn't already exist
-        if other = @astset.definitions[name]
+        if other = @loaded_code.definition(name)
             error("%s is already defined at %s:%s; cannot redefine" % [name, other.file, other.line])
         end
 
@@ -349,14 +358,15 @@ class Puppet::Parser::Parser
             :code => options[:code],
             :parser => self,
             :classname => name,
-            :doc => options[:doc]
+            :doc => options[:doc],
+            :line => options[:line]
         }
 
         [:code, :arguments].each do |param|
             args[param] = options[param] if options[param]
         end
 
-        @astset.definitions[name] = ast AST::Definition, args
+        @loaded_code.add_definition(name, ast(AST::Definition, args))
     end
 
     # Create a new node.  Nodes are special, because they're stored in a global
@@ -365,15 +375,16 @@ class Puppet::Parser::Parser
         names = [names] unless names.instance_of?(Array)
         doc = lexer.getcomment
         names.collect do |name|
-            name = name.to_s.downcase
-            if other = @astset.nodes[name]
+            name = AST::HostName.new :value => name unless name.is_a?(AST::HostName)
+            if other = @loaded_code.node(name)
                 error("Node %s is already defined at %s:%s; cannot redefine" % [other.name, other.file, other.line])
             end
             name = name.to_s if name.is_a?(Symbol)
             args = {
                 :name => name,
                 :parser => self,
-                :doc => doc
+                :doc => doc,
+                :line => options[:line]
             }
             if options[:code]
                 args[:code] = options[:code]
@@ -381,9 +392,10 @@ class Puppet::Parser::Parser
             if options[:parent]
                 args[:parentclass] = options[:parent]
             end
-            @astset.nodes[name] = ast(AST::Node, args)
-            @astset.nodes[name].classname = name
-            @astset.nodes[name]
+            node = ast(AST::Node, args)
+            node.classname = name.to_classname
+            @loaded_code.add_node(name, node)
+            node
         end
     end
 
@@ -391,7 +403,7 @@ class Puppet::Parser::Parser
         if token == 0 # denotes end of file
             value = 'end of file'
         else
-            value = "'%s'" % value
+            value = "'%s'" % value[:value]
         end
         error = "Syntax error at %s" % [value]
 
@@ -446,8 +458,7 @@ class Puppet::Parser::Parser
             # Store the results as the top-level class.
             newclass("", :code => main)
         end
-        @version = Time.now.to_i
-        return @astset
+        return @loaded_code
     ensure
         @lexer.clear
     end
@@ -465,6 +476,17 @@ class Puppet::Parser::Parser
         @lexer.string = string
     end
 
+    def version
+        return @version if defined?(@version)
+
+        if Puppet[:config_version] == ""
+            @version = Time.now.to_i
+            return @version
+        end
+
+        @version = %x{#{Puppet[:config_version]}}.chomp
+    end
+
     # Add a new file to be checked when we're checking to see if we should be
     # reparsed.  This is basically only used by the TemplateWrapper to let the
     # parser know about templates that should be parsed.
@@ -475,7 +497,7 @@ class Puppet::Parser::Parser
     private
 
     def check_and_add_to_watched_files(filename)
-        unless @files.include?(filename)    
+        unless @files.include?(filename)
             @files[filename] = Puppet::Util::LoadedFile.new(filename)
             return true
         else

data/lib/puppet/parser/resource.rb

@@ -5,6 +5,7 @@ class Puppet::Parser::Resource
     require 'puppet/parser/resource/reference'
     require 'puppet/util/tagging'
     require 'puppet/file_collection/lookup'
+    require 'puppet/parser/yaml_trimmer'
 
     include Puppet::FileCollection::Lookup
 
@@ -13,6 +14,7 @@ class Puppet::Parser::Resource
     include Puppet::Util::Errors
     include Puppet::Util::Logging
     include Puppet::Util::Tagging
+    include Puppet::Parser::YamlTrimmer
 
     attr_accessor :source, :scope, :rails_id
     attr_accessor :virtual, :override, :translated
@@ -58,6 +60,12 @@ class Puppet::Parser::Resource
         @ref.builtin = bool
     end
 
+    def eachparam
+        @params.each do |name, param|
+            yield param
+        end
+    end
+
     # Retrieve the associated definition and evaluate it.
     def evaluate
         if klass = @ref.definedtype
@@ -167,49 +175,6 @@ class Puppet::Parser::Resource
         end
     end
 
-    # Modify this resource in the Rails database.  Poor design, yo.
-    def modify_rails(db_resource)
-        args = rails_args
-        args.each do |param, value|
-            db_resource[param] = value unless db_resource[param] == value
-        end
-
-        # Handle file specially
-        if (self.file and  
-            (!db_resource.file or db_resource.file != self.file))
-            db_resource.file = self.file
-        end
-        
-        updated_params = @params.inject({}) do |hash, ary|
-            hash[ary[0].to_s] = ary[1]
-            hash
-        end
-        
-        db_resource.ar_hash_merge(db_resource.get_params_hash(), updated_params,
-                                  :create => Proc.new { |name, parameter|
-                                      parameter.to_rails(db_resource)
-                                  }, :delete => Proc.new { |values|
-                                      values.each { |value| Puppet::Rails::ParamValue.delete(value['id']) }
-                                  }, :modify => Proc.new { |db, mem|
-                                      mem.modify_rails_values(db)
-                                  })
-        
-        updated_tags = tags.inject({}) { |hash, tag| 
-            hash[tag] = tag
-            hash
-        }
-
-        db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
-                                  updated_tags,
-                                  :create => Proc.new { |name, tag|
-                                      db_resource.add_resource_tag(name)
-                                  }, :delete => Proc.new { |tag|
-                                      Puppet::Rails::ResourceTag.delete(tag['id'])
-                                  }, :modify => Proc.new { |db, mem|
-                                      # nothing here
-                                  })
-    end
-
     # Return the resource name, or the title if no name
     # was specified.
     def name
@@ -238,6 +203,8 @@ class Puppet::Parser::Resource
     end
 
     # Define a parameter in our resource.
+    # if we ever receive a parameter named 'tag', set
+    # the resource tags with its value.
     def set_parameter(param, value = nil)
         if value
             param = Puppet::Parser::Resource::Param.new(
@@ -247,6 +214,8 @@ class Puppet::Parser::Resource
             raise ArgumentError, "Must pass a parameter or all necessary values"
         end
 
+        tag(*param.value) if param.name == :tag
+
         # And store it in our parameter hash.
         @params[param.name] = param
     end
@@ -262,91 +231,66 @@ class Puppet::Parser::Resource
         end
     end
 
-    # Turn our parser resource into a Rails resource.  
-    def to_rails(host)
-        args = rails_args
-
-        db_resource = host.resources.build(args)
-
-        # Handle file specially
-        db_resource.file = self.file
-
-        db_resource.save
-
-        @params.each { |name, param|
-            param.to_rails(db_resource)
-        }
-        
-        tags.each { |tag| db_resource.add_resource_tag(tag) }
-
-        return db_resource
-    end
-
-    def to_s
-        self.ref
-    end
-
-    # Translate our object to a transportable object.
-    def to_trans
-        return nil if virtual?
-
-        if builtin?
-            to_transobject
-        else
-            to_transbucket
-        end
-    end
-
-    def to_transbucket
-        bucket = Puppet::TransBucket.new([])
-
-        bucket.type = self.type
-        bucket.name = self.title
 
-        # TransBuckets don't support parameters, which is why they're being deprecated.
-        return bucket
-    end
+    # Create a Puppet::Resource instance from this parser resource.
+    # We plan, at some point, on not needing to do this conversion, but
+    # it's sufficient for now.
+    def to_resource
+        result = Puppet::Resource.new(type, title)
 
-    # Convert this resource to a RAL resource.  We hackishly go via the
-    # transportable stuff.
-    def to_type
-        to_trans.to_type
-    end
-
-    def to_transobject
-        # Now convert to a transobject
-        obj = Puppet::TransObject.new(@ref.title, @ref.type)
         to_hash.each do |p, v|
-            if v.is_a?(Reference)
-                v = v.to_ref
+            if v.is_a?(Puppet::Parser::Resource::Reference)
+                v = Puppet::Resource::Reference.new(v.type, v.title)
             elsif v.is_a?(Array)
-                v = v.collect { |av|
-                    if av.is_a?(Reference)
-                        av = av.to_ref
+                # flatten resource references arrays
+                if v.flatten.find { |av| av.is_a?(Puppet::Parser::Resource::Reference) }
+                    v = v.flatten
+                end
+                v = v.collect do |av|
+                    if av.is_a?(Puppet::Parser::Resource::Reference)
+                        av = Puppet::Resource::Reference.new(av.type, av.title)
                     end
                     av
-                }
+                end
             end
 
             # If the value is an array with only one value, then
             # convert it to a single value.  This is largely so that
             # the database interaction doesn't have to worry about
             # whether it returns an array or a string.
-            obj[p.to_s] = if v.is_a?(Array) and v.length == 1
+            result[p] = if v.is_a?(Array) and v.length == 1
                               v[0]
                           else
                               v
                           end
         end
 
-        obj.file = self.file
-        obj.line = self.line
+        result.file = self.file
+        result.line = self.line
+        result.exported = self.exported
+        result.virtual = self.virtual
+        result.tag(*self.tags)
+
+        return result
+    end
+
+    def to_s
+        self.ref
+    end
+
+    # Translate our object to a transportable object.
+    def to_trans
+        return nil if virtual?
 
-        obj.tags = self.tags
+        return to_resource.to_trans
+    end
 
-        return obj
+    # Convert this resource to a RAL resource.  We hackishly go via the
+    # transportable stuff.
+    def to_ral
+        to_resource.to_ral
     end
-    
+
     private
 
     # Add default values from our definition.
@@ -364,19 +308,16 @@ class Puppet::Parser::Resource
     # from any parent scope, and there's currently no way to turn that off.
     def add_metaparams
         Puppet::Type.eachmetaparam do |name|
+            next if self.class.relationship_parameter?(name)
             # Skip metaparams that we already have defined, unless they're relationship metaparams.
             # LAK:NOTE Relationship metaparams get treated specially -- we stack them, instead of
             # overriding.
-            next if @params[name] and not self.class.relationship_parameter?(name)
+            next if @params[name]
 
             # Skip metaparams for which we get no value.
             next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
-            # The default case: just set the value
             set_parameter(name, val) and next unless @params[name]
-
-            # For relationship params, though, join the values (a la #446).
-            @params[name].value = [@params[name].value, val].flatten
         end
     end
 
@@ -390,7 +331,7 @@ class Puppet::Parser::Resource
     def override_parameter(param)
         # This can happen if the override is defining a new parameter, rather
         # than replacing an existing one.
-        (@params[param.name] = param and return) unless current = @params[param.name]
+        (set_parameter(param) and return) unless current = @params[param.name]
 
         # The parameter is already set.  Fail if they're not allowed to override it.
         unless param.source.child_of?(current.source)
@@ -416,7 +357,7 @@ class Puppet::Parser::Resource
         # so that the source is registered correctly for later overrides.
         param.value = [current.value, param.value].flatten if param.add
 
-        @params[param.name] = param
+        set_parameter(param)
     end
 
     # Verify that all passed parameters are valid.  This throws an error if
@@ -424,7 +365,7 @@ class Puppet::Parser::Resource
     def paramcheck(param)
         param = param.to_s
         # Now make sure it's a valid argument to our class.  These checks
-        # are organized in order of commonhood -- most types, it's a valid 
+        # are organized in order of commonhood -- most types, it's a valid
         # argument and paramcheck is enabled.
         if @ref.typeclass.validattr?(param)
             true
@@ -436,17 +377,6 @@ class Puppet::Parser::Resource
         end
     end
 
-    def rails_args
-        return [:type, :title, :line, :exported].inject({}) do |hash, param|
-            # 'type' isn't a valid column name, so we have to use another name.
-            to = (param == :type) ? :restype : param
-            if value = self.send(param)
-                hash[to] = value
-            end
-            hash
-        end
-    end
-
     # Make sure the resource's parameters are all valid for the type.
     def validate
         @params.each do |name, param|