puppet 0.24.5 → 0.24.6

data/lib/puppet/network/xmlrpc/client.rb

@@ -35,10 +35,6 @@ module Puppet::Network
 
             interface.methods.each { |ary|
                 method = ary[0]
-                if public_method_defined?(method)
-                    raise Puppet::DevError, "Method %s is already defined" %
-                        method
-                end
                 newclient.send(:define_method,method) { |*args|
                     Puppet.debug "Calling %s.%s" % [namespace, method]
                     begin
@@ -51,7 +47,7 @@ module Puppet::Network
                         end
                         ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
                             if detail.message.include?(str)
-                                Puppet.warning "Certificate validation failed; considering using the certname configuration option"
+                                Puppet.warning "Certificate validation failed; consider using the certname configuration option"
                             end
                         end 
                         raise XMLRPCClientError,
@@ -74,6 +70,10 @@ module Puppet::Network
                         Puppet.warning "Other end went away; restarting connection and retrying"
                         self.recycle_connection
                         retry
+                    rescue Timeout::Error => detail
+                        Puppet.err "Connection timeout calling %s.%s: %s" %
+                            [namespace, method, detail.to_s]
+                        raise XMLRPCClientError.new("Connection Timeout").set_backtrace(detail.backtrace)
                     rescue => detail
                         if detail.message =~ /^Wrong size\. Was \d+, should be \d+$/
                             Puppet.warning "XMLRPC returned wrong size.  Retrying."

data/lib/puppet/node.rb

@@ -15,12 +15,7 @@ class Puppet::Node
 
     attr_accessor :name, :classes, :parameters, :source, :ipaddress
     attr_reader :time
-
-    # Set the environment, making sure that it's valid.
-    def environment=(value)
-        raise(ArgumentError, "Invalid environment %s" % value) unless Puppet::Node::Environment.valid?(value)
-        @environment = value
-    end
+    attr_writer :environment
 
     # Do not return environments that are the empty string, and use
     # explicitly set environments, then facts, then a central env
@@ -28,7 +23,6 @@ class Puppet::Node
     def environment
         unless @environment
             if env = parameters["environment"]
-                raise(ArgumentError, "Invalid environment %s from parameters" % env) unless Puppet::Node::Environment.valid?(env)
                 @environment = env
             else
                 @environment = Puppet::Node::Environment.new.name.to_s
@@ -94,8 +88,10 @@ class Puppet::Node
 
         # First, get the fqdn
         unless fqdn = parameters["fqdn"]
-            if domain = parameters["domain"]
-                fqdn = parameters["hostname"] + "." + parameters["domain"]
+            if parameters["hostname"] and parameters["domain"]
+                 fqdn = parameters["hostname"] + "." + parameters["domain"]
+            else
+                 Puppet.warning "Host is missing hostname and/or domain: %s" % name
             end
         end
 

data/lib/puppet/node/environment.rb

@@ -1,30 +1,14 @@
 # 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
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
-        x = 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.
+    # Return an existing environment instance, or create a new one.
     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]

data/lib/puppet/parameter.rb

@@ -413,39 +413,12 @@ class Puppet::Parameter
         @shadow = nil
     end
 
-    # This should only be called for parameters, but go ahead and make
-    # it possible to call for properties, too.
-    def value
-        if self.is_a?(Puppet::Property)
-            # We should return the 'is' value if there's not 'should'
-            # value.  This might be bad, though, because the 'should'
-            # method knows whether to return an array or not and that info
-            # is not exposed, and the 'is' value could be a symbol.  I
-            # can't seem to create a test in which this is a problem, but
-            # that doesn't mean it's not one.
-            if self.should
-                return self.should
-            else
-                return self.retrieve
-            end
-        else
-            if defined? @value
-                return @value
-            else
-                return nil
-            end
-        end
-    end
+    attr_reader :value
 
     # Store the value provided.  All of the checking should possibly be
     # late-binding (e.g., users might not exist when the value is assigned
     # but might when it is asked for).
     def value=(value)
-        # If we're a parameter, just hand the processing off to the should
-        # method.
-        if self.is_a?(Puppet::Property)
-            return self.should = value
-        end
         if respond_to?(:validate)
             validate(value)
         end

data/lib/puppet/parser/ast.rb

@@ -74,19 +74,25 @@ class Puppet::Parser::AST
 end
 
 # And include all of the AST subclasses.
+require 'puppet/parser/ast/arithmetic_operator'
 require 'puppet/parser/ast/astarray'
 require 'puppet/parser/ast/branch'
+require 'puppet/parser/ast/boolean_operator'
 require 'puppet/parser/ast/caseopt'
 require 'puppet/parser/ast/casestatement'
 require 'puppet/parser/ast/collection'
 require 'puppet/parser/ast/collexpr'
+require 'puppet/parser/ast/comparison_operator'
 require 'puppet/parser/ast/definition'
 require 'puppet/parser/ast/else'
 require 'puppet/parser/ast/function'
 require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/ifstatement'
 require 'puppet/parser/ast/leaf'
+require 'puppet/parser/ast/minus'
 require 'puppet/parser/ast/node'
+require 'puppet/parser/ast/nop'
+require 'puppet/parser/ast/not'
 require 'puppet/parser/ast/resource'
 require 'puppet/parser/ast/resource_defaults'
 require 'puppet/parser/ast/resource_override'

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

@@ -0,0 +1,41 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    class ArithmeticOperator < AST::Branch
+
+        attr_accessor :operator, :lval, :rval
+
+        # Iterate across all of our children.
+        def each
+            [@lval,@rval,@operator].each { |child| yield child }
+        end
+
+        # Returns a boolean which is the result of the boolean operation
+        # of lval and rval operands
+        def evaluate(scope)
+            # evaluate the operands, should return a boolean value
+            lval = @lval.safeevaluate(scope)
+            lval = Puppet::Parser::Scope.number?(lval)
+            if lval == nil
+                raise ArgumentError, "left operand of %s is not a number" % @operator
+            end
+            rval = @rval.safeevaluate(scope)
+            rval = Puppet::Parser::Scope.number?(rval)
+            if rval == nil
+                raise ArgumentError, "right operand of %s is not a number" % @operator
+            end
+
+            # compute result
+            lval.send(@operator, rval)
+        end
+
+        def initialize(hash)
+            super
+
+            unless %w{+ - * / << >>}.include?(@operator)
+                raise ArgumentError, "Invalid arithmetic operator %s" % @operator
+            end
+        end
+    end
+end

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

@@ -0,0 +1,48 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    class BooleanOperator < AST::Branch
+
+        attr_accessor :operator, :lval, :rval
+
+        # Iterate across all of our children.
+        def each
+            [@lval,@rval,@operator].each { |child| yield child }
+        end
+
+        # Returns a boolean which is the result of the boolean operation
+        # of lval and rval operands
+        def evaluate(scope)
+            # evaluate the first operand, should return a boolean value
+            lval = @lval.safeevaluate(scope)
+            
+            # return result
+            # lazy evaluate right operand
+            case @operator
+            when "and";
+                if Puppet::Parser::Scope.true?(lval)
+                    rval = @rval.safeevaluate(scope)
+                    Puppet::Parser::Scope.true?(rval)
+                else # false and false == false
+                    false
+                end
+            when "or"; 
+                if Puppet::Parser::Scope.true?(lval) 
+                    true
+                else
+                    rval = @rval.safeevaluate(scope)
+                    Puppet::Parser::Scope.true?(rval)
+                end
+            end
+        end
+
+        def initialize(hash)
+            super
+
+            unless %w{and or}.include?(@operator)
+                raise ArgumentError, "Invalid boolean operator %s" % @operator
+            end
+        end
+    end
+end

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

@@ -30,7 +30,12 @@ class CollExpr < AST::Branch
             case @oper
             when "and": code1.call(resource) and code2.call(resource)
             when "or": code1.call(resource) or code2.call(resource)
-            when "==": resource[str1] == str2
+            when "==":
+                if resource[str1].is_a?(Array) && form != :exported
+                    resource[str1].include?(str2)
+                else
+                    resource[str1] == str2
+                end
             when "!=": resource[str1] != str2
             end
         end

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

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

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

@@ -0,0 +1,23 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+# An object that returns a boolean which is the boolean not
+# of the given value.
+class Puppet::Parser::AST
+    class Minus < AST::Branch
+        attr_accessor :value
+
+        def each
+            yield @value
+        end
+
+        def evaluate(scope)
+            val = @value.safeevaluate(scope)
+            val = Puppet::Parser::Scope.number?(val)
+            if val == nil
+                raise ArgumentError, "minus operand %s is not a number" % val
+            end
+            return -val
+        end
+    end
+end

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

@@ -0,0 +1,11 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # This class is a no-op, it doesn't produce anything
+    # when evaluated, hence it's name :-)
+    class Nop < AST::Leaf
+        def evaluate(scope)
+            # nothing to do
+        end
+    end
+end

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

@@ -0,0 +1,19 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+# An object that returns a boolean which is the boolean not
+# of the given value.
+class Puppet::Parser::AST
+    class Not < AST::Branch
+        attr_accessor :value
+
+        def each
+            yield @value
+        end
+
+        def evaluate(scope)
+            val = @value.safeevaluate(scope)
+            return ! Puppet::Parser::Scope.true?(val)
+        end
+    end
+end

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

@@ -19,7 +19,7 @@ class Puppet::Parser::AST
         # in the current scope.
         def evaluate(scope)
             # Get our object reference.
-            object = @object.safeevaluate(scope)
+            resource = @object.safeevaluate(scope)
 
             hash = {}
 
@@ -30,21 +30,28 @@ class Puppet::Parser::AST
 
             # Now we just create a normal resource, but we call a very different
             # method on the scope.
-            obj = Puppet::Parser::Resource.new(
-                :type => object.type,
-                :title => object.title,
-                :params => params,
-                :file => @file,
-                :line => @line,
-                :source => scope.source,
-                :scope => scope
-            )
-
-            # Now we tell the scope that it's an override, and it behaves as
-            # necessary.
-            scope.compiler.add_override(obj)
-
-            obj
+            resource = [resource] unless resource.is_a?(Array)
+            
+            resource = resource.collect do |r|
+                res = Puppet::Parser::Resource.new(
+                    :type => r.type,
+                    :title => r.title,
+                    :params => params,
+                    :file => @file,
+                    :line => @line,
+                    :source => scope.source,
+                    :scope => scope
+                )
+
+                # Now we tell the scope that it's an override, and it behaves as
+                # necessary.
+                scope.compiler.add_override(res)
+
+                res
+            end
+            # decapsulate array in case of only one item
+            return resource.pop if resource.length == 1
+            return resource
         end
 
         # Create our ResourceDef.  Handles type checking for us.

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

@@ -24,16 +24,20 @@ class Puppet::Parser::AST
         # and name.
         def evaluate(scope)
             title = @title.safeevaluate(scope)
+            title = [title] unless title.is_a?(Array)
+            
             if @type.to_s.downcase == "class"
-                objtype = "class"
-                title = qualified_class(scope, title)
+                resource_type = "class"
+                title = title.collect { |t| qualified_class(scope, t) }
             else
-                objtype = qualified_type(scope)
+                resource_type = qualified_type(scope)
             end
 
-            return Puppet::Parser::Resource::Reference.new(
-                :type => objtype, :title => title
-            )
+            title = title.collect { |t| Puppet::Parser::Resource::Reference.new(
+                :type => resource_type, :title => t
+            ) }
+            return title.pop if title.length == 1
+            return title
         end
 
         # Look up a fully qualified class name.