puppet 0.23.2 → 0.24.0

data/lib/puppet/node/environment.rb

@@ -0,0 +1,46 @@
+# Model the environment that a node can operate in.  This class just
+# provides a simple wrapper for the functionality around environments.
+class Puppet::Node::Environment
+    # Return the list of valid environments.  Just looks them up in
+    # the settings.
+    def self.valid
+        Puppet.settings.value(:environments).split(",").collect { |e| e.to_sym }
+    end
+
+    # Is the provided environment valid?
+    def self.valid?(name)
+        return false if name.to_s == ""
+        valid.include?(name.to_sym)
+    end
+
+    @seen = {}
+
+    # Return an existing environment instance, or create a new one,
+    # validating the environment name.
+    def self.new(name = nil)
+        name ||= Puppet.settings.value(:environment)
+
+        raise ArgumentError, "Environment name must be specified" unless name
+
+        raise(ArgumentError, "'%s' is not a valid environment" % name) unless valid?(name)
+
+        symbol = name.to_sym
+
+        return @seen[symbol] if @seen[symbol]
+
+        obj = self.allocate
+        obj.send :initialize, symbol
+        @seen[symbol] = obj
+    end
+
+    attr_reader :name
+
+    # Return an environment-specific setting.
+    def [](param)
+        Puppet.settings.value(param, self.name)
+    end
+
+    def initialize(name)
+        @name = name
+    end
+end

data/lib/puppet/node/facts.rb

@@ -0,0 +1,36 @@
+require 'puppet/node'
+require 'puppet/indirector'
+
+# Manage a given node's facts.  This either accepts facts and stores them, or
+# returns facts for a given node.
+class Puppet::Node::Facts
+    # Set up indirection, so that nodes can be looked for in
+    # the node sources.
+    extend Puppet::Indirector
+
+    # Use the node source as the indirection terminus.
+    indirects :facts, :terminus_class => :facter
+
+    attr_accessor :name, :values
+
+    def initialize(name, values = {})
+        @name = name
+        @values = values
+
+        add_internal
+    end
+
+    private
+
+    # Add internal data to the facts for storage.
+    def add_internal
+        self.values[:_timestamp] = Time.now
+    end
+
+    # Strip out that internal data.
+    def strip_internal
+        newvals = values.dup
+        newvals.find_all { |name, value| name.to_s =~ /^_/ }.each { |name, value| newvals.delete(name) }
+        newvals
+    end
+end

data/lib/puppet/parameter.rb

@@ -1,6 +1,7 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
+require 'puppet/util/docs'
 
 class Puppet::Parameter
     include Puppet::Util
@@ -10,6 +11,7 @@ class Puppet::Parameter
     include Puppet::Util::MethodHelper
     class << self
         include Puppet::Util
+        include Puppet::Util::Docs
         attr_reader :validater, :munger, :name, :default, :required_features
         attr_accessor :metaparam
 
@@ -287,9 +289,6 @@ class Puppet::Parameter
             raise Puppet::DevError, "No resource set for %s" % self.class.name
         end
 
-        # LAK 2007-05-09: Keep the @parent around for backward compatibility.
-        #@parent = @resource
-
         if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
             setup_shadow(klass)
         end
@@ -376,36 +375,37 @@ class Puppet::Parameter
         vals = self.class.values
         regs = self.class.regexes
 
-        if regs.is_a? Hash # this is true on properties
-            regs = regs.keys
-        end
-        if vals.empty? and regs.empty?
-            # This parameter isn't using defined values to do its work.
-            return 
-        end
+        # this is true on properties
+        regs = regs.keys if regs.is_a?(Hash)
+
+        # This parameter isn't using defined values to do its work.
+        return if vals.empty? and regs.empty?
+
         newval = value
-        unless value.is_a?(Symbol)
-            newval = value.to_s.intern
-        end
+        newval = value.to_s.intern unless value.is_a?(Symbol)
 
-        unless vals.include?(newval) or
-            self.class.alias(newval) or
-            self.class.match?(value) # We match the string, not the symbol
-                str = "Invalid '%s' value %s. " %
-                    [self.class.name, value.inspect]
+        name = newval
 
-                unless vals.empty?
-                    str += "Valid values are %s. " % vals.join(", ")
-                end
+        unless vals.include?(newval) or name = self.class.alias(newval) or name = self.class.match?(value) # We match the string, not the symbol
+            str = "Invalid '%s' value %s. " %
+                [self.class.name, value.inspect]
 
-                unless regs.empty?
-                    str += "Valid values match %s." % regs.collect { |r|
-                        r.to_s
-                    }.join(", ")
-                end
+            unless vals.empty?
+                str += "Valid values are %s. " % vals.join(", ")
+            end
+
+            unless regs.empty?
+                str += "Valid values match %s." % regs.collect { |r|
+                    r.to_s
+                }.join(", ")
+            end
 
-                raise ArgumentError, str
+            raise ArgumentError, str
         end
+
+        # Now check for features.
+        name = name[0] if name.is_a?(Array) # This is true for regexes.
+        validate_features_per_value(name) if is_a?(Puppet::Property)
     end
 
     def remove
@@ -482,6 +482,12 @@ class Puppet::Parameter
     def to_s
         s = "Parameter(%s)" % self.name
     end
+
+    # Make sure that we've got all of the required features for a given value.
+    def validate_features_per_value(value)
+        if features = self.class.value_option(value, :required_features)
+            raise ArgumentError, "Provider must have features '%s' to set '%s' to '%s'" % [features, self.class.name, value] unless provider.satisfies?(features)
+        end
+    end
 end
 
-# $Id: parameter.rb 2647 2007-07-04 22:25:23Z luke $

data/lib/puppet/parser/ast.rb

@@ -117,4 +117,3 @@ end
 
 require 'puppet/parser/ast/leaf'
 
-# $Id: ast.rb 2742 2007-08-03 23:49:53Z luke $

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

@@ -21,45 +21,39 @@ class Puppet::Parser::AST
             # We basically always operate declaratively, and when we
             # do we need to evaluate the settor-like statements first.  This
             # is basically variable and type-default declarations.
-            if scope.declarative?
-                # This is such a stupid hack.  I've no real idea how to make a
-                # "real" declarative language, so I hack it so it looks like
-                # one, yay.
-                settors = []
-                others = []
+            # This is such a stupid hack.  I've no real idea how to make a
+            # "real" declarative language, so I hack it so it looks like
+            # one, yay.
+            settors = []
+            others = []
 
-                # Make a new array, so we don't have to deal with the details of
-                # flattening and such
-                items = []
-                
-                # First clean out any AST::ASTArrays
-                @children.each { |child|
-                    if child.instance_of?(AST::ASTArray)
-                        child.each do |ac|
-                            if ac.class.settor?
-                                settors << ac
-                            else
-                                others << ac
-                            end
-                        end
-                    else
-                        if child.class.settor?
-                            settors << child
+            # Make a new array, so we don't have to deal with the details of
+            # flattening and such
+            items = []
+            
+            # First clean out any AST::ASTArrays
+            @children.each { |child|
+                if child.instance_of?(AST::ASTArray)
+                    child.each do |ac|
+                        if ac.class.settor?
+                            settors << ac
                         else
-                            others << child
+                            others << ac
                         end
                     end
-                }
-                rets = [settors, others].flatten.collect { |child|
-                    child.safeevaluate(:scope => scope)
-                }
-                return rets.reject { |o| o.nil? }
-            else
-                # If we're not declarative, just do everything in order.
-                return @children.collect { |item|
-                    item.safeevaluate(:scope => scope)
-                }.reject { |o| o.nil? }
-            end
+                else
+                    if child.class.settor?
+                        settors << child
+                    else
+                        others << child
+                    end
+                end
+            }
+
+            rets = [settors, others].flatten.collect { |child|
+                child.safeevaluate(:scope => scope)
+            }
+            return rets.reject { |o| o.nil? }
         end
 
         def push(*ary)
@@ -72,28 +66,11 @@ class Puppet::Parser::AST
 
             return self
         end
-
-        # Convert to a string.  Only used for printing the parse tree.
-        def to_s
-            return "[" + @children.collect { |child|
-                child.to_s
-            }.join(", ") + "]"
-        end
-
-        # Print the parse tree.
-        def tree(indent = 0)
-            #puts((AST.indent * indent) + self.pin)
-            self.collect { |child|
-                child.tree(indent)
-            }.join("\n" + (AST.midline * (indent+1)) + "\n")
-        end
     end
 
     # A simple container class, containing the parameters for an object.
     # Used for abstracting the grammar declarations.  Basically unnecessary
     # except that I kept finding bugs because I had too many arrays that
     # meant completely different things.
-    class ResourceInst < ASTArray; end
+    class ResourceInstance < ASTArray; end
 end
-
-# $Id: astarray.rb 1739 2006-10-06 03:13:15Z luke $

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

@@ -35,15 +35,5 @@ class Puppet::Parser::AST
                 end
             }
         end
-
-        # Pretty-print the parse tree.
-        def tree(indent = 0)
-            return ((@@indline * indent) +
-                self.typewrap(self.pin)) + "\n" + self.collect { |child|
-                    child.tree(indent + 1)
-            }.join("\n")
-        end
     end
 end
-
-# $Id: branch.rb 1484 2006-08-22 23:34:40Z luke $

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

@@ -56,16 +56,5 @@ class Puppet::Parser::AST
         def evaluate(hash)
             return @statements.safeevaluate(hash)
         end
-
-        def tree(indent = 0)
-            rettree = [
-                @value.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @statements.tree(indent + 1)
-            ]
-            return rettree.flatten.join("\n")
-        end
     end
 end
-
-# $Id: caseopt.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -51,20 +51,8 @@ class Puppet::Parser::AST
             return retvalue
         end
 
-        def tree(indent = 0)
-            rettree = [
-                @test.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @options.tree(indent + 1)
-            ]
-
-            return rettree.flatten.join("\n")
-        end
-
         def each
             [@test,@options].each { |child| yield child }
         end
     end
 end
-
-# $Id: casestatement.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -20,11 +20,9 @@ class Collection < AST::Branch
 
         newcoll = Puppet::Parser::Collector.new(scope, @type, str, code, self.form)
 
-        scope.newcollection(newcoll)
+        scope.compile.add_collection(newcoll)
 
         newcoll
     end
 end
 end
-
-# $Id: collection.rb 1805 2006-10-18 00:22:45Z luke $

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

@@ -77,5 +77,3 @@ class CollExpr < AST::Branch
     end
 end
 end
-
-# $Id: collexpr.rb 2714 2007-07-19 18:12:20Z luke $

data/lib/puppet/parser/ast/{component.rb → definition.rb}

@@ -4,7 +4,7 @@ class Puppet::Parser::AST
     # Evaluate the stored parse tree for a given component.  This will
     # receive the arguments passed to the component and also the type and
     # name of the component.
-    class Component < AST::Branch
+    class Definition < AST::Branch
         include Puppet::Util
         include Puppet::Util::Warnings
         include Puppet::Util::MethodHelper
@@ -27,78 +27,26 @@ class Puppet::Parser::AST
             false
         end
 
-        def evaluate(hash)
-            origscope = hash[:scope]
-            title = hash[:title]
-            args = symbolize_options(hash[:arguments] || {})
+        def evaluate(options)
+            origscope = options[:scope]
+            resource = options[:resource]
 
-            name = args[:name] || title
-
-            exported = hash[:exported]
-            virtual = hash[:virtual]
-
-            pscope = origscope
-            scope = subscope(pscope, title)
-
-            if virtual or origscope.virtual?
-                scope.virtual = true
-            end
-
-            if exported or origscope.exported?
-                scope.exported = true
-            end
+            # Create a new scope.
+            scope = subscope(origscope, resource)
 
             # Additionally, add a tag for whatever kind of class
             # we are
             if @classname != "" and ! @classname.nil?
-                @classname.split(/::/).each { |tag| scope.tag(tag) }
+                @classname.split(/::/).each { |tag| scope.resource.tag(tag) }
             end
 
-            [name, title].each do |str|
+            [resource.name, resource.title].each do |str|
                 unless str.nil? or str =~ /[^\w]/ or str == ""
-                    scope.tag(str)
+                    scope.resource.tag(str)
                 end
             end
 
-            # define all of the arguments in our local scope
-            if self.arguments
-                # Verify that all required arguments are either present or
-                # have been provided with defaults.
-                self.arguments.each { |arg, default|
-                    arg = symbolize(arg)
-                    unless args.include?(arg)
-                        if defined? default and ! default.nil?
-                            default = default.safeevaluate :scope => scope
-                            args[arg] = default
-                            #Puppet.debug "Got default %s for %s in %s" %
-                            #    [default.inspect, arg.inspect, @name.inspect]
-                        else
-                            parsefail "Must pass %s to %s of type %s" %
-                                    [arg,title,@classname]
-                        end
-                    end
-                }
-            end
-
-            # Set each of the provided arguments as variables in the
-            # component's scope.
-            args.each { |arg,value|
-                unless validattr?(arg)
-                    parsefail "%s does not accept attribute %s" % [@classname, arg]
-                end
-
-                exceptwrap do
-                    scope.setvar(arg.to_s,args[arg])
-                end
-            }
-
-            unless args.include? :title
-                scope.setvar("title",title)
-            end
-
-            unless args.include? :name
-                scope.setvar("name",name)
-            end
+            set_resource_parameters(scope, resource)
 
             if self.code
                 return self.code.safeevaluate(:scope => scope)
@@ -130,11 +78,9 @@ class Puppet::Parser::AST
             @arguments.each do |arg, defvalue|
                 next unless Puppet::Type.metaparamclass(arg)
                 if defvalue
-                    warnonce "%s is a metaparam; this value will inherit to all contained elements" % arg
+                    warnonce "%s is a metaparam; this value will inherit to all contained resources" % arg
                 else
-                    raise Puppet::ParseError,
-                        "%s is a metaparameter; please choose another name" %
-                        name
+                    raise Puppet::ParseError, "%s is a metaparameter; please choose another parameter name in the %s definition" % [arg, self.classname]
                 end
             end
         end
@@ -175,14 +121,15 @@ class Puppet::Parser::AST
         end
 
         # Create a new subscope in which to evaluate our code.
-        def subscope(scope, name = nil)
+        def subscope(scope, resource)
             args = {
-                :type => self.classname,
+                :resource => resource,
                 :keyword => self.keyword,
-                :namespace => self.namespace
+                :namespace => self.namespace,
+                :source => self
             }
 
-            args[:name] = name if name
+            oldscope = scope
             scope = scope.newscope(args)
             scope.source = self
 
@@ -220,7 +167,46 @@ class Puppet::Parser::AST
                 return false
             end
         end
+
+        private
+
+        # Set any arguments passed by the resource as variables in the scope.
+        def set_resource_parameters(scope, resource)
+            args = symbolize_options(resource.to_hash || {})
+
+            # Verify that all required arguments are either present or
+            # have been provided with defaults.
+            if self.arguments
+                self.arguments.each { |arg, default|
+                    arg = symbolize(arg)
+                    unless args.include?(arg)
+                        if defined? default and ! default.nil?
+                            default = default.safeevaluate :scope => scope
+                            args[arg] = default
+                            #Puppet.debug "Got default %s for %s in %s" %
+                            #    [default.inspect, arg.inspect, @name.inspect]
+                        else
+                            parsefail "Must pass %s to %s of type %s" %
+                                    [arg, resource.title, @classname]
+                        end
+                    end
+                }
+            end
+
+            # Set each of the provided arguments as variables in the
+            # definition's scope.
+            args.each { |arg,value|
+                unless validattr?(arg)
+                    parsefail "%s does not accept attribute %s" % [@classname, arg]
+                end
+
+                exceptwrap do
+                    scope.setvar(arg.to_s, args[arg])
+                end
+            }
+
+            scope.setvar("title", resource.title) unless args.include? :title
+            scope.setvar("name", resource.name) unless args.include? :name
+        end
     end
 end
-
-# $Id: component.rb 2742 2007-08-03 23:49:53Z luke $