puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,129 @@
+require 'puppet/sslcertificates'
+require 'openssl'
+require 'puppet/external/base64'
+
+require 'xmlrpc/client'
+require 'yaml'
+
+module Puppet::Network
+    class ClientError < Puppet::Error; end
+    class XMLRPCClientError < Puppet::Error; end
+    class XMLRPCClient < ::XMLRPC::Client
+        attr_accessor :puppet_server, :puppet_port
+        @clients = {}
+
+        class << self
+            include Puppet::Util
+            include Puppet::Util::ClassGen
+        end
+
+        # Create a netclient for each handler
+        def self.mkclient(handler)
+            interface = handler.interface
+            namespace = interface.prefix
+
+            # Create a subclass for every client type.  This is
+            # so that all of the methods are on their own class,
+            # so that they namespaces can define the same methods if
+            # they want.
+            constant = handler.name.to_s.capitalize
+            name = namespace.downcase
+            newclient = genclass(name, :hash => @clients,
+                :constant => constant)
+
+            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
+                        call("%s.%s" % [namespace, method.to_s],*args)
+                    rescue OpenSSL::SSL::SSLError => detail
+                        raise XMLRPCClientError,
+                            "Certificates were not trusted: %s" % detail
+                    rescue ::XMLRPC::FaultException => detail
+                        #Puppet.err "Could not call %s.%s: %s" %
+                        #    [namespace, method, detail.faultString]
+                        #raise XMLRPCClientError,
+                        #    "XMLRPC Error: %s" % detail.faultString
+                        raise XMLRPCClientError, detail.faultString
+                    rescue Errno::ECONNREFUSED => detail
+                        msg = "Could not connect to %s on port %s" %
+                            [@host, @port]
+                        raise XMLRPCClientError, msg
+                    rescue SocketError => detail
+                        Puppet.err "Could not find server %s: %s" %
+                            [@puppet_server, detail.to_s]
+                        error = XMLRPCClientError.new(
+                            "Could not find server %s" % @puppet_server
+                        )
+                        error.set_backtrace detail.backtrace
+                        raise error
+                    rescue => detail
+                        Puppet.err "Could not call %s.%s: %s" %
+                            [namespace, method, detail.inspect]
+                        error = XMLRPCClientError.new(detail.to_s)
+                        error.set_backtrace detail.backtrace
+                        raise error
+                    end
+                }
+            }
+
+            return newclient
+        end
+
+        def self.handler_class(handler)
+            @clients[handler] || self.mkclient(handler)
+        end
+
+        # Use cert information from a Puppet client to set up the http object.
+        def cert_setup(client)
+            unless FileTest.exists?(Puppet[:localcacert])
+                raise Puppet::SSLCertificates::Support::MissingCertificate,
+                    "Could not find ca certificate %s" % Puppet[:localcacert]
+            end
+            @http.ca_file = Puppet[:localcacert]
+            store = OpenSSL::X509::Store.new
+            store.add_file Puppet[:localcacert]
+            store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
+            @http.cert_store = store
+            @http.cert = client.cert
+            @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            @http.key = client.key
+        end
+
+        def initialize(hash = {})
+            hash[:Path] ||= "/RPC2"
+            hash[:Server] ||= Puppet[:server]
+            hash[:Port] ||= Puppet[:masterport]
+
+            @puppet_server = hash[:Server]
+            @puppet_port = hash[:Port]
+
+            super(
+                hash[:Server],
+                hash[:Path],
+                hash[:Port],
+                nil, # proxy_host
+                nil, # proxy_port
+                nil, # user
+                nil, # password
+                true, # use_ssl
+                120 # a two minute timeout, instead of 30 seconds
+            )
+        end
+
+        def local
+            false
+        end
+
+        def local?
+            false
+        end
+    end
+end
+
+# $Id: client.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -0,0 +1,91 @@
+require 'puppet/network/authorization'
+require 'xmlrpc/server'
+
+# Just silly.
+class ::XMLRPC::FaultException
+    def to_s
+        self.message
+    end
+end
+
+module Puppet::Network
+    # Most of our subclassing is just so that we can get
+    # access to information from the request object, like
+    # the client name and IP address.
+    module XMLRPCProcessor
+        include Puppet::Network::Authorization
+
+        ERR_UNAUTHORIZED = 30
+
+        def add_handler(interface, handler)
+            @loadedhandlers << interface.prefix
+            super(interface, handler)
+        end
+
+        def handler_loaded?(handler)
+            @loadedhandlers.include?(handler.to_s)
+        end
+
+        # Convert our data and client request into xmlrpc calls, and verify
+        # they're authorized and such-like.  This method differs from the
+        # default in that it expects a ClientRequest object in addition to the
+        # data.
+        def process(data, request)
+            call, params = parser().parseMethodCall(data)
+            params << request.name << request.ip
+            handler, method = call.split(".")
+            request.handler = handler
+            request.method = method
+            begin
+                verify(request)
+            rescue InvalidClientRequest => detail
+                raise ::XMLRPC::FaultException.new(ERR_UNAUTHORIZED, detail.to_s)
+            end
+            handle(request.call, *params)
+        end
+
+        private
+
+        # Provide error handling for method calls.
+        def protect_service(obj, *args)
+            begin
+                obj.call(*args)
+            rescue ::XMLRPC::FaultException
+                raise
+            rescue Puppet::AuthorizationError => detail
+                Puppet.err "Permission denied: %s" % detail.to_s
+                raise ::XMLRPC::FaultException.new(
+                    1, detail.to_s
+                )
+            rescue Puppet::Error => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                Puppet.err detail.to_s
+                error = ::XMLRPC::FaultException.new(
+                    1, detail.to_s
+                )
+                error.set_backtrace detail.backtrace
+                raise error
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                Puppet.err "Could not call: %s" % detail.to_s
+                error = ::XMLRPC::FaultException.new(1, detail.to_s)
+                error.set_backtrace detail.backtrace
+                raise error
+            end
+        end
+
+        # Set up our service hook and init our handler list.
+        def setup_processor
+            @loadedhandlers = []
+            self.set_service_hook do |obj, *args|
+                protect_service(obj, *args)
+            end
+        end
+    end
+end
+
+# $Id: processor.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -0,0 +1,20 @@
+require 'xmlrpc/server'
+require 'puppet/network/authorization'
+require 'puppet/network/xmlrpc/processor'
+
+module Puppet::Network
+    # Most of our subclassing is just so that we can get
+    # access to information from the request object, like
+    # the client name and IP address.
+    class XMLRPCServer < ::XMLRPC::BasicServer
+        include Puppet::Util
+        include Puppet::Network::XMLRPCProcessor
+
+        def initialize
+            super()
+            setup_processor()
+        end
+    end
+end
+
+# $Id: server.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -0,0 +1,121 @@
+require 'xmlrpc/server'
+require 'puppet/network/authorization'
+require 'puppet/network/xmlrpc/processor'
+
+module Puppet::Network::XMLRPC
+    class ServletError < RuntimeError; end
+    class WEBrickServlet < ::XMLRPC::WEBrickServlet
+        include Puppet::Network::XMLRPCProcessor
+
+        # This is a hackish way to avoid an auth message every time we have a
+        # normal operation
+        def self.log(msg)
+            unless defined? @logs
+                @logs = {}
+            end
+            if @logs.include?(msg)
+                @logs[msg] += 1
+            else
+                Puppet.info msg
+                @logs[msg] = 1
+            end
+        end
+
+        # Accept a list of handlers and register them all.
+        def initialize(handlers)
+            # the servlet base class does not consume any arguments
+            # and its BasicServer base class only accepts a 'class_delim'
+            # option which won't change in Puppet at all
+            # thus, we don't need to pass any args to our base class,
+            # and we can consume them all ourselves
+            super()
+
+            setup_processor()
+
+            # Set up each of the passed handlers.
+            handlers.each do |handler|
+                add_handler(handler.class.interface, handler)
+            end
+        end
+
+        # Handle the actual request.  We can't use the super() method, because
+        # we need to pass a ClientRequest object to process() so we can do
+        # authorization.  It's the only way to stay thread-safe.
+        def service(request, response)
+            if @valid_ip 
+                raise WEBrick::HTTPStatus::Forbidden unless @valid_ip.any? { |ip| request.peeraddr[3] =~ ip }
+            end
+
+            if request.request_method != "POST"
+                raise WEBrick::HTTPStatus::MethodNotAllowed,
+                    "unsupported method `#{request.request_method}'."
+            end
+
+            if parse_content_type(request['Content-type']).first != "text/xml" 
+                raise WEBrick::HTTPStatus::BadRequest
+            end 
+
+            length = (request['Content-length'] || 0).to_i
+
+            raise WEBrick::HTTPStatus::LengthRequired unless length > 0
+
+            data = request.body
+
+            if data.nil? or data.size != length
+                raise WEBrick::HTTPStatus::BadRequest
+            end
+
+            resp = process(data, client_request(request))
+            if resp.nil? or resp.size <= 0  
+                raise WEBrick::HTTPStatus::InternalServerError
+            end
+
+            response.status = 200
+            response['Content-Length'] = resp.size
+            response['Content-Type']   = "text/xml; charset=utf-8"
+            response.body = resp 
+        end
+
+        private
+
+        # Generate a ClientRequest object for later validation.
+        def client_request(request)
+            if peer = request.peeraddr
+                client = peer[2]
+                clientip = peer[3]
+            else
+                raise ::XMLRPC::FaultException.new(
+                    ERR_UNCAUGHT_EXCEPTION,
+                    "Could not retrieve client information"
+                )
+            end
+
+            # If they have a certificate (which will almost always be true)
+            # then we get the hostname from the cert, instead of via IP
+            # info
+            valid = false
+            if cert = request.client_cert
+                nameary = cert.subject.to_a.find { |ary|
+                    ary[0] == "CN"
+                }   
+
+                if nameary.nil?
+                    Puppet.warning "Could not retrieve server name from cert"
+                else
+                    unless client == nameary[1]
+                        Puppet.debug "Overriding %s with cert name %s" %
+                            [client, nameary[1]]
+                        client = nameary[1]
+                    end
+                    valid = true
+                end
+            end
+
+            info = Puppet::Network::ClientRequest.new(client, clientip, valid)
+
+            return info
+        end
+    end
+end
+
+# $Id: webrick_servlet.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/parameter.rb

@@ -1,431 +1,475 @@
-module Puppet
-    class Parameter < Puppet::Element
-        class << self
-            attr_reader :validater, :munger, :name, :default
-            attr_accessor :ismetaparameter, :element
-
-            # Define the default value for a given parameter or parameter.  This
-            # means that 'nil' is an invalid default value.  This defines
-            # the 'default' instance method.
-            def defaultto(value = nil, &block)
-                if block
-                    define_method(:default, &block)
-                else
-                    if value.nil?
-                        raise Puppet::DevError,
-                            "Either a default value or block must be provided"
-                    end
-                    define_method(:default) do value end
+require 'puppet/util/methodhelper'
+
+class Puppet::Parameter < Puppet::Element
+    include Puppet::Util::MethodHelper
+    class << self
+        attr_reader :validater, :munger, :name, :default, :required_features
+        attr_accessor :metaparam, :element
+
+        # Define the default value for a given parameter or parameter.  This
+        # means that 'nil' is an invalid default value.  This defines
+        # the 'default' instance method.
+        def defaultto(value = nil, &block)
+            if block
+                define_method(:default, &block)
+            else
+                if value.nil?
+                    raise Puppet::DevError,
+                        "Either a default value or block must be provided"
                 end
+                define_method(:default) do value end
             end
+        end
 
-            # Return a documentation string.  If there are valid values,
-            # then tack them onto the string.
-            def doc
-                @doc ||= ""
-
-                unless defined? @addeddocvals
-                    unless values.empty?
-                        if @aliasvalues.empty?
-                            @doc += "  Valid values are ``" +
-                                values.join("``, ``") + "``."
-                        else
-                            @doc += "  Valid values are "
-
-                            @doc += values.collect do |value|
-                                ary = @aliasvalues.find do |name, val|
-                                    val == value
-                                end
-                                if ary
-                                    "``%s`` (also called ``%s``)" % [value, ary[0]]
-                                else
-                                    "``#{value}``"
-                                end
-                            end.join(", ") + "."
-                        end
-                    end
+        # Return a documentation string.  If there are valid values,
+        # then tack them onto the string.
+        def doc
+            @doc ||= ""
 
-                    if defined? @parameterregexes and ! @parameterregexes.empty?
-                        regs = @parameterregexes
-                        if @parameterregexes.is_a? Hash
-                            regs = @parameterregexes.keys
-                        end
-                        unless regs.empty?
-                            @doc += "  Values can also match ``" +
-                                regs.join("``, ``") + "``."
-                        end
+            unless defined? @addeddocvals
+                unless values.empty?
+                    if @aliasvalues.empty?
+                        @doc += "  Valid values are ``" +
+                            values.join("``, ``") + "``."
+                    else
+                        @doc += "  Valid values are "
+
+                        @doc += values.collect do |value|
+                            ary = @aliasvalues.find do |name, val|
+                                val == value
+                            end
+                            if ary
+                                "``%s`` (also called ``%s``)" % [value, ary[0]]
+                            else
+                                "``#{value}``"
+                            end
+                        end.join(", ") + "."
                     end
-                    @addeddocvals = true
                 end
 
-                @doc
-            end
+                if defined? @parameterregexes and ! @parameterregexes.empty?
+                    regs = @parameterregexes
+                    if @parameterregexes.is_a? Hash
+                        regs = @parameterregexes.keys
+                    end
+                    unless regs.empty?
+                        @doc += "  Values can also match ``" +
+                            regs.join("``, ``") + "``."
+                    end
+                end
 
-            def nodefault
-                if public_method_defined? :default
-                    undef_method :default
+                if f = self.required_features
+                    @doc += "  Requires features %s." % f.flatten.collect { |f| f.to_s }.join(" ")
                 end
+                @addeddocvals = true
             end
 
-            # Store documentation for this parameter.
-            def desc(str)
-                @doc = str
-            end
+            @doc
+        end
 
-            def initvars
-                @parametervalues = []
-                @aliasvalues = {}
-                @parameterregexes = []
+        def nodefault
+            if public_method_defined? :default
+                undef_method :default
             end
+        end
 
-            # This is how we munge the value.  Basically, this is our
-            # opportunity to convert the value from one form into another.
-            def munge(&block)
-                # I need to wrap the unsafe version in begin/rescue parameterments,
-                # but if I directly call the block then it gets bound to the
-                # class's context, not the instance's, thus the two methods,
-                # instead of just one.
-                define_method(:unsafe_munge, &block)
-
-                define_method(:munge) do |*args|
-                    begin
-                        unsafe_munge(*args)
-                    rescue Puppet::Error => detail
-                        Puppet.debug "Reraising %s" % detail
-                        raise
-                    rescue => detail
-                        if Puppet[:debug]
-                            puts detail.backtrace
-                        end
-                        raise Puppet::DevError, "Munging failed for class %s: %s" %
-                            [self.name, detail]
-                    end
-                end
-                #@munger = block
-            end
+        # Store documentation for this parameter.
+        def desc(str)
+            @doc = str
+        end
 
-            # Mark whether we're the namevar.
-            def isnamevar
-                @isnamevar = true
-                @required = true
-            end
+        def initvars
+            @parametervalues = []
+            @aliasvalues = {}
+            @parameterregexes = []
+        end
 
-            # Is this parameter the namevar?  Defaults to false.
-            def isnamevar?
-                if defined? @isnamevar
-                    return @isnamevar
-                else
-                    return false
+        # This is how we munge the value.  Basically, this is our
+        # opportunity to convert the value from one form into another.
+        def munge(&block)
+            # I need to wrap the unsafe version in begin/rescue parameterments,
+            # but if I directly call the block then it gets bound to the
+            # class's context, not the instance's, thus the two methods,
+            # instead of just one.
+            define_method(:unsafe_munge, &block)
+
+            define_method(:munge) do |*args|
+                begin
+                    ret = unsafe_munge(*args)
+                rescue Puppet::Error => detail
+                    Puppet.debug "Reraising %s" % detail
+                    raise
+                rescue => detail
+                    raise Puppet::DevError, "Munging failed for value %s in class %s: %s" %
+                        [args.inspect, self.name, detail], detail.backtrace
                 end
-            end
 
-            # This parameter is required.
-            def isrequired
-                @required = true
-            end
-
-            # Is this parameter required?  Defaults to false.
-            def required?
-                if defined? @required
-                    return @required
-                else
-                    return false
+                if self.shadow
+                    self.shadow.munge(*args)
                 end
+                ret
             end
+        end
 
-            def to_s
-                if self.ismetaparameter
-                    "Puppet::Type::" + @name.to_s.capitalize
-                else
-                    self.element.to_s + @name.to_s.capitalize
-                end
-            end
+        # Mark whether we're the namevar.
+        def isnamevar
+            @isnamevar = true
+            @required = true
+        end
 
-            # Verify that we got a good value
-            def validate(&block)
-                #@validater = block
-                define_method(:unsafe_validate, &block)
-
-                define_method(:validate) do |*args|
-                    begin
-                        unsafe_validate(*args)
-                    rescue ArgumentError, Puppet::Error, TypeError
-                        raise
-                    rescue => detail
-                        if Puppet[:debug]
-                            puts detail.backtrace
-                        end
-                        raise Puppet::DevError,
-                            "Validate method failed for class %s: %s" %
-                            [self.name, detail]
-                    end
-                end
+        # Is this parameter the namevar?  Defaults to false.
+        def isnamevar?
+            if defined? @isnamevar
+                return @isnamevar
+            else
+                return false
             end
+        end
 
-            # Does the value match any of our regexes?
-            def match?(value)
-                value = value.to_s unless value.is_a? String
-                @parameterregexes.find { |r|
-                    r = r[0] if r.is_a? Array # States use a hash here
-                    r =~ value
-                }
-            end
+        # This parameter is required.
+        def isrequired
+            @required = true
+        end
 
-            # Define a new value for our parameter.
-            def newvalues(*names)
-                names.each { |name|
-                    name = name.intern if name.is_a? String
-
-                    case name
-                    when Symbol
-                        if @parametervalues.include?(name)
-                            Puppet.warning "%s already has a value for %s" %
-                                [name, name]
-                        end
-                        @parametervalues << name
-                    when Regexp
-                        if @parameterregexes.include?(name)
-                            Puppet.warning "%s already has a value for %s" %
-                                [name, name]
-                        end
-                        @parameterregexes << name
-                    else
-                        raise ArgumentError, "Invalid value %s of type %s" %
-                            [name, name.class]
-                    end
-                }
+        # Is this parameter required?  Defaults to false.
+        def required?
+            if defined? @required
+                return @required
+            else
+                return false
             end
+        end
 
-            def aliasvalue(name, other)
-                unless @parametervalues.include?(other)
+        # Verify that we got a good value
+        def validate(&block)
+            #@validater = block
+            define_method(:unsafe_validate, &block)
+
+            define_method(:validate) do |*args|
+                begin
+                    unsafe_validate(*args)
+                rescue ArgumentError, Puppet::Error, TypeError
+                    raise
+                rescue => detail
                     raise Puppet::DevError,
-                        "Cannot alias nonexistent value %s" % other
+                        "Validate method failed for class %s: %s" %
+                        [self.name, detail], detail.backtrace
                 end
-
-                @aliasvalues[name] = other
             end
+        end
 
-            def alias(name)
-                @aliasvalues[name]
-            end
+        # Does the value match any of our regexes?
+        def match?(value)
+            value = value.to_s unless value.is_a? String
+            @parameterregexes.find { |r|
+                r = r[0] if r.is_a? Array # Properties use a hash here
+                r =~ value
+            }
+        end
 
-            def regexes
-                return @parameterregexes.dup
-            end
+        # Define a new value for our parameter.
+        def newvalues(*names)
+            names.each { |name|
+                name = name.intern if name.is_a? String
 
-            # Return the list of valid values.
-            def values
-                #[@aliasvalues.keys, @parametervalues.keys].flatten
-                if @parametervalues.is_a? Array
-                    return @parametervalues.dup
-                elsif @parametervalues.is_a? Hash
-                    return @parametervalues.keys
+                case name
+                when Symbol
+                    if @parametervalues.include?(name)
+                        Puppet.warning "%s already has a value for %s" %
+                            [name, name]
+                    end
+                    @parametervalues << name
+                when Regexp
+                    if @parameterregexes.include?(name)
+                        Puppet.warning "%s already has a value for %s" %
+                            [name, name]
+                    end
+                    @parameterregexes << name
                 else
-                    return []
+                    raise ArgumentError, "Invalid value %s of type %s" %
+                        [name, name.class]
                 end
-            end
+            }
         end
 
-        # Just a simple method to proxy instance methods to class methods
-        def self.proxymethods(*values)
-            values.each { |val|
-                define_method(val) do
-                    self.class.send(val)
-                end
-            }
+        def aliasvalue(name, other)
+            other = symbolize(other)
+            unless @parametervalues.include?(other)
+                raise Puppet::DevError,
+                    "Cannot alias nonexistent value %s" % other
+            end
+
+            @aliasvalues[name] = other
         end
 
-        # And then define one of these proxies for each method in our
-        # ParamHandler class.
-        proxymethods("required?", "isnamevar?")
+        def alias(name)
+            @aliasvalues[name]
+        end
 
-        attr_accessor :parent
+        def regexes
+            return @parameterregexes.dup
+        end
 
-        def devfail(msg)
-            self.fail(Puppet::DevError, msg)
+        def required_features=(*args)
+            @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
         end
 
-        def fail(*args)
-            type = nil
-            if args[0].is_a?(Class)
-                type = args.shift
+        # Return the list of valid values.
+        def values
+            #[@aliasvalues.keys, @parametervalues.keys].flatten
+            if @parametervalues.is_a? Array
+                return @parametervalues.dup
+            elsif @parametervalues.is_a? Hash
+                return @parametervalues.keys
             else
-                type = Puppet::Error
+                return []
             end
+        end
+    end
 
-            error = type.new(args.join(" "))
-
-            if defined? @parent and @parent and @parent.line
-                error.line = @parent.line
+    # Just a simple method to proxy instance methods to class methods
+    def self.proxymethods(*values)
+        values.each { |val|
+            define_method(val) do
+                self.class.send(val)
             end
+        }
+    end
 
-            if defined? @parent and @parent and @parent.file
-                error.file = @parent.file
-            end
+    # And then define one of these proxies for each method in our
+    # ParamHandler class.
+    proxymethods("required?", "isnamevar?")
 
-            raise error
-        end
+    attr_accessor :parent
+    attr_reader :shadow
 
-        # Log a message using the parent's log level.
-        def log(msg)
-            unless @parent[:loglevel]
-                p @parent
-                self.devfail "Parent %s has no loglevel" %
-                    @parent.name
-            end
-            Puppet::Log.create(
-                :level => @parent[:loglevel],
-                :message => msg,
-                :source => self
-            )
+    def devfail(msg)
+        self.fail(Puppet::DevError, msg)
+    end
+
+    def fail(*args)
+        type = nil
+        if args[0].is_a?(Class)
+            type = args.shift
+        else
+            type = Puppet::Error
         end
 
-        # each parameter class must define the name() method, and parameter
-        # instances do not change that name this implicitly means that a given
-        # object can only have one parameter instance of a given parameter
-        # class
-        def name
-            return self.class.name
+        error = type.new(args.join(" "))
+
+        if defined? @parent and @parent and @parent.line
+            error.line = @parent.line
         end
 
-        # for testing whether we should actually do anything
-        def noop
-            unless defined? @noop
-                @noop = false
-            end
-            tmp = @noop || self.parent.noop || Puppet[:noop] || false
-            #debug "noop is %s" % tmp
-            return tmp
+        if defined? @parent and @parent and @parent.file
+            error.file = @parent.file
         end
 
-        # return the full path to us, for logging and rollback; not currently
-        # used
-        def path
-            return [@parent.path, self.name].join("/")
+        raise error
+    end
+
+    # Basic parameter initialization.
+    def initialize(options = {})
+        options = symbolize_options(options)
+        if parent = options[:parent]
+            self.parent = parent
+            options.delete(:parent)
+        else
+            raise Puppet::DevError, "No parent set for %s" % self.class.name
         end
 
-        # If the specified value is allowed, then munge appropriately.
-        munge do |value|
-            if self.class.values.empty? and self.class.regexes.empty?
-                # This parameter isn't using defined values to do its work.
-                return value
-            end
+        if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
+            setup_shadow(klass)
+        end
 
-            # We convert to a string and then a symbol so that things like
-            # booleans work as we expect.
-            intern = value.to_s.intern
-
-            # If it's a valid value, always return it as a symbol.
-            if self.class.values.include?(intern)
-                retval = intern
-            elsif other = self.class.alias(intern)
-                retval = other
-            elsif ary = self.class.match?(value)
-                retval = value
-            else
-                # If it passed the validation but is not a registered value,
-                # we just return it as is.
-                retval = value
-            end
+        set_options(options)
+    end
 
-            retval
+    # Log a message using the parent's log level.
+    def log(msg)
+        unless @parent[:loglevel]
+            p @parent
+            self.devfail "Parent %s has no loglevel" %
+                @parent.name
         end
+        Puppet::Util::Log.create(
+            :level => @parent[:loglevel],
+            :message => msg,
+            :source => self
+        )
+    end
 
-        # Verify that the passed value is valid.
-        validate do |value|
-            vals = self.class.values
-            regs = self.class.regexes
+    # Is this parameter a metaparam?
+    def metaparam?
+        self.class.metaparam
+    end
 
-            if regs.is_a? Hash # this is true on states
-                regs = regs.keys
-            end
-            if vals.empty? and regs.empty?
-                # This parameter isn't using defined values to do its work.
-                return 
-            end
-            newval = value
-            unless value.is_a?(Symbol)
-                newval = value.to_s.intern
-            end
+    # each parameter class must define the name() method, and parameter
+    # instances do not change that name this implicitly means that a given
+    # object can only have one parameter instance of a given parameter
+    # class
+    def name
+        return self.class.name
+    end
 
-            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]
+    # for testing whether we should actually do anything
+    def noop
+        unless defined? @noop
+            @noop = false
+        end
+        tmp = @noop || self.parent.noop || Puppet[:noop] || false
+        #debug "noop is %s" % tmp
+        return tmp
+    end
 
-                    unless vals.empty?
-                        str += "Valid values are %s. " % vals.join(", ")
-                    end
+    # return the full path to us, for logging and rollback; not currently
+    # used
+    def pathbuilder
+        if defined? @parent and @parent
+            return [@parent.pathbuilder, self.name]
+        else
+            return [self.name]
+        end
+    end
 
-                    unless regs.empty?
-                        str += "Valid values match %s." % regs.collect { |r|
-                            r.to_s
-                        }.join(", ")
-                    end
+    # If the specified value is allowed, then munge appropriately.
+    munge do |value|
+        if self.class.values.empty? and self.class.regexes.empty?
+            # This parameter isn't using defined values to do its work.
+            return value
+        end
 
-                    raise ArgumentError, str
-            end
+        # We convert to a string and then a symbol so that things like
+        # booleans work as we expect.
+        intern = value.to_s.intern
+
+        # If it's a valid value, always return it as a symbol.
+        if self.class.values.include?(intern)
+            retval = intern
+        elsif other = self.class.alias(intern)
+            retval = other
+        elsif ary = self.class.match?(value)
+            retval = value
+        else
+            # If it passed the validation but is not a registered value,
+            # we just return it as is.
+            retval = value
         end
 
-        def remove
-            @parent = nil
+        retval
+    end
+
+    # Verify that the passed value is valid.
+    validate do |value|
+        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
+        newval = value
+        unless value.is_a?(Symbol)
+            newval = value.to_s.intern
         end
 
-        # This should only be called for parameters, but go ahead and make
-        # it possible to call for states, too.
-        def value
-            if self.is_a?(Puppet::State)
-                # 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.is
+        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]
+
+                unless vals.empty?
+                    str += "Valid values are %s. " % vals.join(", ")
                 end
-            else
-                if defined? @value
-                    return @value
-                else
-                    return nil
+
+                unless regs.empty?
+                    str += "Valid values match %s." % regs.collect { |r|
+                        r.to_s
+                    }.join(", ")
                 end
-            end
+
+                raise ArgumentError, str
         end
+    end
 
-        # 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::State)
-                return self.should = value
+    def remove
+        @parent = nil
+        @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.is
             end
-            if respond_to?(:validate)
-                validate(value)
+        else
+            if defined? @value
+                return @value
+            else
+                return nil
             end
+        end
+    end
 
-            if respond_to?(:munge)
-                value = munge(value)
-            end
-            @value = 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
 
-        def inspect
-            s = "Parameter(%s = %s" % [self.name, self.value || "nil"]
-            if defined? @parent
-                s += ", @parent = %s)" % @parent
-            else
-                s += ")"
-            end
+        if respond_to?(:munge)
+            value = munge(value)
         end
+        @value = value
+    end
 
-        def to_s
-            s = "Parameter(%s)" % self.name
+    def inspect
+        s = "Parameter(%s = %s" % [self.name, self.value || "nil"]
+        if defined? @parent
+            s += ", @parent = %s)" % @parent
+        else
+            s += ")"
         end
     end
+
+    # Retrieve the parent's provider.  Some types don't have providers, in which
+    # case we return the parent object itself.
+    def provider
+        @parent.provider || @parent
+    end
+
+    # If there's a shadowing metaparam, instantiate it now.
+    # This allows us to create a property or parameter with the
+    # same name as a metaparameter, and the metaparam will only be
+    # stored as a shadow.
+    def setup_shadow(klass)
+        @shadow = klass.new(:parent => self.parent)
+    end
+
+    def to_s
+        s = "Parameter(%s)" % self.name
+    end
 end
+
+# $Id: parameter.rb 2414 2007-04-25 20:59:00Z luke $