puppet 0.25.5 → 2.6.0

data/lib/puppet/parser/templatewrapper.rb

@@ -3,114 +3,112 @@
 require 'puppet/parser/files'
 
 class Puppet::Parser::TemplateWrapper
-    attr_writer :scope
-    attr_reader :file
-    attr_accessor :string
-    include Puppet::Util
-    Puppet::Util.logmethods(self)
-
-    def initialize(scope)
-        @__scope__ = scope
+  attr_writer :scope
+  attr_reader :file
+  attr_accessor :string
+  include Puppet::Util
+  Puppet::Util.logmethods(self)
+
+  def initialize(scope)
+    @__scope__ = scope
+  end
+
+  def scope
+    @__scope__
+  end
+
+  # Should return true if a variable is defined, false if it is not
+  def has_variable?(name)
+    if scope.lookupvar(name.to_s, false) != :undefined
+      true
+    else
+      false
     end
-
-    def scope
-        @__scope__
+  end
+
+  # Allow templates to access the defined classes
+  def classes
+    scope.catalog.classes
+  end
+
+  # Allow templates to access the tags defined in the current scope
+  def tags
+    scope.tags
+  end
+
+  # Allow templates to access the all the defined tags
+  def all_tags
+    scope.catalog.tags
+  end
+
+  # Ruby treats variables like methods, so we used to expose variables
+  # within scope to the ERB code via method_missing.  As per RedMine #1427,
+  # though, this means that conflicts between methods in our inheritance
+  # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
+  #
+  # Worse, /new/ conflicts could pop up when a new kernel or object method
+  # was added to Ruby, causing templates to suddenly fail mysteriously when
+  # Ruby was upgraded.
+  #
+  # To ensure that legacy templates using unqualified names work we retain
+  # the missing_method definition here until we declare the syntax finally
+  # dead.
+  def method_missing(name, *args)
+    # We have to tell lookupvar to return :undefined to us when
+    # appropriate; otherwise it converts to "".
+    value = scope.lookupvar(name.to_s, false)
+    if value != :undefined
+      return value
+    else
+      # Just throw an error immediately, instead of searching for
+      # other missingmethod things or whatever.
+      raise Puppet::ParseError, "Could not find value for '#{name}'"
     end
+  end
 
-    # Should return true if a variable is defined, false if it is not
-    def has_variable?(name)
-        if scope.lookupvar(name.to_s, false) != :undefined
-            true
-        else
-            false
-        end
+  def file=(filename)
+    unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment.to_s)
+      raise Puppet::ParseError, "Could not find template '#{filename}'"
     end
 
-    # Allow templates to access the defined classes
-    def classes
-        return scope.catalog.classes
-    end
+    # We'll only ever not have a parser in testing, but, eh.
+    scope.known_resource_types.watch_file(file)
 
-    # Allow templates to access the tags defined in the current scope
-    def tags
-        return scope.tags
-    end
+    @string = File.read(file)
+  end
 
-    # Allow templates to access the all the defined tags
-    def all_tags
-        return scope.catalog.tags
+  def result(string = nil)
+    if string
+      self.string = string
+      template_source = "inline template"
+    else
+      template_source = file
     end
 
-    # Ruby treats variables like methods, so we used to expose variables
-    # within scope to the ERB code via method_missing.  As per RedMine #1427,
-    # though, this means that conflicts between methods in our inheritance
-    # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
-    #
-    # Worse, /new/ conflicts could pop up when a new kernel or object method
-    # was added to Ruby, causing templates to suddenly fail mysteriously when
-    # Ruby was upgraded.
-    #
-    # To ensure that legacy templates using unqualified names work we retain
-    # the missing_method definition here until we declare the syntax finally
-    # dead.
-    def method_missing(name, *args)
-        # We have to tell lookupvar to return :undefined to us when
-        # appropriate; otherwise it converts to "".
-        value = scope.lookupvar(name.to_s, false)
-        if value != :undefined
-            return value
+    # Expose all the variables in our scope as instance variables of the
+    # current object, making it possible to access them without conflict
+    # to the regular methods.
+    benchmark(:debug, "Bound template variables for #{template_source}") do
+      scope.to_hash.each { |name, value|
+        if name.kind_of?(String)
+          realname = name.gsub(/[^\w]/, "_")
         else
-            # Just throw an error immediately, instead of searching for
-            # other missingmethod things or whatever.
-            raise Puppet::ParseError, "Could not find value for '%s'" % name
+          realname = name
         end
+        instance_variable_set("@#{realname}", value)
+      }
     end
 
-    def file=(filename)
-        unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
-            raise Puppet::ParseError, "Could not find template '%s'" % filename
-        end
-
-        # We'll only ever not have a parser in testing, but, eh.
-        if scope.parser
-            scope.parser.watch_file(file)
-        end
-
-        @string = File.read(file)
+    result = nil
+    benchmark(:debug, "Interpolated template #{template_source}") do
+      template = ERB.new(self.string, 0, "-")
+      result = template.result(binding)
     end
 
-    def result(string = nil)
-        if string
-            self.string = string
-            template_source = "inline template"
-        else
-            template_source = file
-        end
+    result
+  end
 
-        # Expose all the variables in our scope as instance variables of the
-        # current object, making it possible to access them without conflict
-        # to the regular methods.
-        benchmark(:debug, "Bound template variables for #{template_source}") do
-            scope.to_hash.each { |name, value|
-                if name.kind_of?(String)
-                    realname = name.gsub(/[^\w]/, "_")
-                else
-                    realname = name
-                end
-                instance_variable_set("@#{realname}", value)
-            }
-        end
-
-        result = nil
-        benchmark(:debug, "Interpolated template #{template_source}") do
-            template = ERB.new(self.string, 0, "-")
-            result = template.result(binding)
-        end
-
-        result
-    end
-
-    def to_s
-        "template[%s]" % (file ? file : "inline")
-    end
+  def to_s
+    "template[#{(file ? file : "inline")}]"
+  end
 end

data/lib/puppet/parser/type_loader.rb

@@ -0,0 +1,146 @@
+require 'puppet/node/environment'
+
+class Puppet::Parser::TypeLoader
+  include Puppet::Node::Environment::Helper
+
+  class Helper < Hash
+    include MonitorMixin
+    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
+
+  # Import our files.
+  def import(file, current_file = nil)
+    return if Puppet[:ignoreimport]
+
+    # use a path relative to the file doing the importing
+    if current_file
+      dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
+    else
+      dir = "."
+    end
+    if dir == ""
+      dir = "."
+    end
+
+    pat = file
+    modname, 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.each do |file|
+      unless file =~ /^#{File::SEPARATOR}/
+        file = File.join(dir, file)
+      end
+      unless imported? file
+        @imported[file] = true
+        parse_file(file)
+      end
+    end
+
+    modname
+  end
+
+  def imported?(file)
+    @imported.has_key?(file)
+  end
+
+  def known_resource_types
+    environment.known_resource_types
+  end
+
+  def initialize(env)
+    self.environment = env
+    @loaded = {}
+    @loading = Helper.new
+
+    @imported = {}
+  end
+
+  def load_until(namespaces, name)
+    return nil if name == "" # special-case main.
+    name2files(namespaces, name).each do |filename|
+      modname = begin
+        import_if_possible(filename)
+      rescue Puppet::ImportError => detail
+        # We couldn't load the item
+        # I'm not convienced we should just drop these errors, but this
+        # preserves existing behaviours.
+        nil
+      end
+      if result = yield(filename)
+        Puppet.info "Automatically imported #{name} from #{filename} into #{environment}"
+        result.module_name = modname if modname and result.respond_to?(:module_name=)
+        return result
+      end
+    end
+    nil
+  end
+
+  def loaded?(name)
+    @loaded.include?(name)
+  end
+
+  def name2files(namespaces, name)
+    return [name.sub(/^::/, '').gsub("::", File::SEPARATOR)] if name =~ /^::/
+
+    result = namespaces.inject([]) do |names_to_try, namespace|
+      fullname = (namespace + "::#{name}").sub(/^::/, '')
+
+      # Try to load the module init file if we're a qualified name
+      names_to_try << fullname.split("::")[0] if fullname.include?("::")
+
+      # Then the fully qualified name
+      names_to_try << fullname
+    end
+
+    # 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.
+    result << name
+    result.uniq.collect { |f| f.gsub("::", File::SEPARATOR) }
+  end
+
+  def parse_file(file)
+    Puppet.debug("importing '#{file}' in environment #{environment}")
+    parser = Puppet::Parser::Parser.new(environment)
+    parser.file = file
+    parser.parse
+  end
+
+  # Utility method factored out of load for handling thread-safety.
+  # This isn't tested in the specs, because that's basically impossible.
+  def import_if_possible(file, current_file = nil)
+    @loaded[file] || begin
+      case @loading.owner_of(file)
+      when :this_thread
+        nil
+      when :another_thread
+        import_if_possible(file,current_file)
+      when :nobody
+        @loaded[file] = import(file,current_file)
+      end
+    ensure
+      @loading.done_with(file)
+    end
+  end
+end

data/lib/puppet/parser/yaml_trimmer.rb

@@ -1,11 +1,9 @@
 module Puppet::Parser::YamlTrimmer
-    REMOVE = %w{@scope @source}
+  REMOVE = %w{@scope @source}
 
-    def to_yaml_properties
-        r = instance_variables - REMOVE
-        if respond_to?(:skip_for_yaml)
-            r -= skip_for_yaml()
-        end
-        r
-    end
+  def to_yaml_properties
+    r = instance_variables - REMOVE
+    r -= skip_for_yaml if respond_to?(:skip_for_yaml)
+    r
+  end
 end

data/lib/puppet/property.rb

@@ -5,483 +5,320 @@ require 'puppet'
 require 'puppet/parameter'
 
 class Puppet::Property < Puppet::Parameter
+  require 'puppet/property/ensure'
 
-    # Because 'should' uses an array, we have a special method for handling
-    # it.  We also want to keep copies of the original values, so that
-    # they can be retrieved and compared later when merging.
-    attr_reader :shouldorig
-
-    attr_writer :noop
-
-    class << self
-        attr_accessor :unmanaged
-        attr_reader :name
-
-        # Return array matching info, defaulting to just matching
-        # the first value.
-        def array_matching
-            unless defined?(@array_matching)
-                @array_matching = :first
-            end
-            @array_matching
-        end
-
-        # Set whether properties should match all values or just the first one.
-        def array_matching=(value)
-            value = value.intern if value.is_a?(String)
-            unless [:first, :all].include?(value)
-                raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'"
-            end
-            @array_matching = value
-        end
-
-        def checkable
-            @checkable = true
-        end
-
-        def uncheckable
-            @checkable = false
-        end
-
-        def checkable?
-            if defined? @checkable
-                return @checkable
-            else
-                return true
-            end
-        end
-    end
+  # Because 'should' uses an array, we have a special method for handling
+  # it.  We also want to keep copies of the original values, so that
+  # they can be retrieved and compared later when merging.
+  attr_reader :shouldorig
 
-    # Look up a value's name, so we can find options and such.
-    def self.value_name(name)
-        if value = value_collection.match?(name)
-            value.name
-        end
-    end
+  attr_writer :noop
 
-    # Retrieve an option set when a value was defined.
-    def self.value_option(name, option)
-        if value = value_collection.value(name)
-            value.send(option)
-        end
-    end
+  class << self
+    attr_accessor :unmanaged
+    attr_reader :name
 
-    # Define a new valid value for a property.  You must provide the value itself,
-    # usually as a symbol, or a regex to match the value.
-    #
-    # The first argument to the method is either the value itself or a regex.
-    # The second argument is an option hash; valid options are:
-    # * <tt>:method</tt>: The name of the method to define.  Defaults to 'set_<value>'.
-    # * <tt>:required_features</tt>: A list of features this value requires.
-    # * <tt>:event</tt>: The event that should be returned when this value is set.
-    # * <tt>:call</tt>: When to call any associated block.  The default value
-    #   is ``instead``, which means to call the value instead of calling the
-    #   provider.  You can also specify ``before`` or ``after``, which will
-    #   call both the block and the provider, according to the order you specify
-    #   (the ``first`` refers to when the block is called, not the provider).
-    def self.newvalue(name, options = {}, &block)
-        value = value_collection.newvalue(name, options, &block)
-
-        if value.method and value.block
-            define_method(value.method, &value.block)
-        end
-        value
+    # Return array matching info, defaulting to just matching
+    # the first value.
+    def array_matching
+      @array_matching ||= :first
     end
 
-    # Call the provider method.
-    def call_provider(value)
-        begin
-            provider.send(self.class.name.to_s + "=", value)
-        rescue NoMethodError
-            self.fail "The %s provider can not handle attribute %s" %
-                [provider.class.name, self.class.name]
-        end
+    # Set whether properties should match all values or just the first one.
+    def array_matching=(value)
+      value = value.intern if value.is_a?(String)
+      raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'" unless [:first, :all].include?(value)
+      @array_matching = value
     end
+  end
 
-    # Call the dynamically-created method associated with our value, if
-    # there is one.
-    def call_valuemethod(name, value)
-        event = nil
-        if method = self.class.value_option(name, :method) and self.respond_to?(method)
-            #self.debug "setting %s (currently %s)" % [value, self.retrieve]
-
-            begin
-                event = self.send(method)
-            rescue Puppet::Error
-                raise
-            rescue => detail
-                if Puppet[:trace]
-                    puts detail.backtrace
-                end
-                error = Puppet::Error.new("Could not set %s on %s: %s" %
-                    [value, self.class.name, detail], @resource.line, @resource.file)
-                error.set_backtrace detail.backtrace
-                raise error
-            end
-        elsif block = self.class.value_option(name, :block)
-            # FIXME It'd be better here to define a method, so that
-            # the blocks could return values.
-            event = self.instance_eval(&block)
-        else
-            devfail "Could not find method for value '%s'" % name
-        end
-        return event, name
+  # Look up a value's name, so we can find options and such.
+  def self.value_name(name)
+    if value = value_collection.match?(name)
+      value.name
     end
+  end
 
-    # How should a property change be printed as a string?
-    def change_to_s(currentvalue, newvalue)
-        begin
-            if currentvalue == :absent
-                return "defined '%s' as '%s'" %
-                    [self.name, self.should_to_s(newvalue)]
-            elsif newvalue == :absent or newvalue == [:absent]
-                return "undefined %s from '%s'" %
-                    [self.name, self.is_to_s(currentvalue)]
-            else
-                return "%s changed '%s' to '%s'" %
-                    [self.name, self.is_to_s(currentvalue), self.should_to_s(newvalue)]
-            end
-        rescue Puppet::Error, Puppet::DevError
-            raise
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            raise Puppet::DevError, "Could not convert change %s to string: %s" %
-                [self.name, detail]
-        end
+  # Retrieve an option set when a value was defined.
+  def self.value_option(name, option)
+    if value = value_collection.value(name)
+      value.send(option)
     end
-
-    # Figure out which event to return.
-    def event(name, event = nil)
-        if value_event = self.class.value_option(name, :event)
-            return value_event
-        end
-
-        if event and event.is_a?(Symbol)
-            if event == :nochange
-                return nil
-            else
-                return event
-            end
-        end
-
-        if self.class.name == :ensure
-            event = case self.should
-            when :present; (@resource.class.name.to_s + "_created").intern
-            when :absent; (@resource.class.name.to_s + "_removed").intern
-            else
-                (@resource.class.name.to_s + "_changed").intern
-            end
-        else
-            event = (@resource.class.name.to_s + "_changed").intern
-        end
-
-        return event
+  end
+
+  # Define a new valid value for a property.  You must provide the value itself,
+  # usually as a symbol, or a regex to match the value.
+  #
+  # The first argument to the method is either the value itself or a regex.
+  # The second argument is an option hash; valid options are:
+  # * <tt>:method</tt>: The name of the method to define.  Defaults to 'set_<value>'.
+  # * <tt>:required_features</tt>: A list of features this value requires.
+  # * <tt>:event</tt>: The event that should be returned when this value is set.
+  # * <tt>:call</tt>: When to call any associated block.  The default value
+  #   is ``instead``, which means to call the value instead of calling the
+  #   provider.  You can also specify ``before`` or ``after``, which will
+  #   call both the block and the provider, according to the order you specify
+  #   (the ``first`` refers to when the block is called, not the provider).
+  def self.newvalue(name, options = {}, &block)
+    value = value_collection.newvalue(name, options, &block)
+
+    define_method(value.method, &value.block) if value.method and value.block
+    value
+  end
+
+  # Call the provider method.
+  def call_provider(value)
+      provider.send(self.class.name.to_s + "=", value)
+  rescue NoMethodError
+      self.fail "The #{provider.class.name} provider can not handle attribute #{self.class.name}"
+  end
+
+  # Call the dynamically-created method associated with our value, if
+  # there is one.
+  def call_valuemethod(name, value)
+    if method = self.class.value_option(name, :method) and self.respond_to?(method)
+      begin
+        event = self.send(method)
+      rescue Puppet::Error
+        raise
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        error = Puppet::Error.new("Could not set '#{value} on #{self.class.name}: #{detail}", @resource.line, @resource.file)
+        error.set_backtrace detail.backtrace
+        raise error
+      end
+    elsif block = self.class.value_option(name, :block)
+      # FIXME It'd be better here to define a method, so that
+      # the blocks could return values.
+      self.instance_eval(&block)
+    else
+      devfail "Could not find method for value '#{name}'"
     end
-
-    attr_reader :shadow
-
-    # initialize our property
-    def initialize(hash = {})
-        super
-
-        if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
-            setup_shadow(klass)
-        end
+  end
+
+  # How should a property change be printed as a string?
+  def change_to_s(current_value, newvalue)
+    begin
+      if current_value == :absent
+        return "defined '#{name}' as '#{should_to_s(newvalue)}'"
+      elsif newvalue == :absent or newvalue == [:absent]
+        return "undefined '#{name}' from '#{is_to_s(current_value)}'"
+      else
+        return "#{name} changed '#{is_to_s(current_value)}' to '#{should_to_s(newvalue)}'"
+      end
+    rescue Puppet::Error, Puppet::DevError
+      raise
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      raise Puppet::DevError, "Could not convert change '#{name}' to string: #{detail}"
     end
+  end
 
-    # Determine whether the property is in-sync or not.  If @should is
-    # not defined or is set to a non-true value, then we do not have
-    # a valid value for it and thus consider the property to be in-sync
-    # since we cannot fix it.  Otherwise, we expect our should value
-    # to be an array, and if @is matches any of those values, then
-    # we consider it to be in-sync.
-    def insync?(is)
-        #debug "%s value is '%s', should be '%s'" %
-        #    [self,self.is.inspect,self.should.inspect]
-        unless defined? @should and @should
-            return true
-        end
-
-        unless @should.is_a?(Array)
-            self.devfail "%s's should is not array" % self.class.name
-        end
-
-        # an empty array is analogous to no should values
-        if @should.empty?
-            return true
-        end
-
-        # Look for a matching value
-        if match_all?
-            return (is == @should or is == @should.collect { |v| v.to_s })
-        else
-            @should.each { |val|
-                if is == val or is == val.to_s
-                    return true
-                end
-            }
-        end
-
-        # otherwise, return false
-        return false
-    end
+  # Figure out which event to return.
+  def event_name
+    value = self.should
 
-    # because the @should and @is vars might be in weird formats,
-    # we need to set up a mechanism for pretty printing of the values
-    # default to just the values, but this way individual properties can
-    # override these methods
-    def is_to_s(currentvalue)
-        currentvalue
-    end
+    event_name = self.class.value_option(value, :event) and return event_name
 
-    # Send a log message.
-    def log(msg)
-        unless @resource[:loglevel]
-            self.devfail "Parent %s has no loglevel" % @resource.name
-        end
-        Puppet::Util::Log.create(
-            :level => @resource[:loglevel],
-            :message => msg,
-            :source => self
-        )
-    end
+    name == :ensure or return (name.to_s + "_changed").to_sym
 
-    # Should we match all values, or just the first?
-    def match_all?
-        self.class.array_matching == :all
-    end
+    return (resource.type.to_s + case value
+    when :present; "_created"
+    when :absent; "_removed"
+    else
+      "_changed"
+    end).to_sym
+  end
 
-    # Execute our shadow's munge code, too, if we have one.
-    def munge(value)
-        self.shadow.munge(value) if self.shadow
+  # Return a modified form of the resource event.
+  def event
+    resource.event :name => event_name, :desired_value => should, :property => self, :source_description => path
+  end
 
-        super
-    end
+  attr_reader :shadow
 
-    # each property class must define the name() method, and property instances
-    # do not change that name
-    # this implicitly means that a given object can only have one property
-    # instance of a given property class
-    def name
-        return self.class.name
-    end
+  # initialize our property
+  def initialize(hash = {})
+    super
 
-    # for testing whether we should actually do anything
-    def noop
-        # This is only here to make testing easier.
-        if @resource.respond_to?(:noop?)
-            @resource.noop?
-        else
-            if defined?(@noop)
-                @noop
-            else
-                Puppet[:noop]
-            end
-        end
+    if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
+      setup_shadow(klass)
     end
-
-    # By default, call the method associated with the property name on our
-    # provider.  In other words, if the property name is 'gid', we'll call
-    # 'provider.gid' to retrieve the current value.
-    def retrieve
-        provider.send(self.class.name)
+  end
+
+  # Determine whether the property is in-sync or not.  If @should is
+  # not defined or is set to a non-true value, then we do not have
+  # a valid value for it and thus consider the property to be in-sync
+  # since we cannot fix it.  Otherwise, we expect our should value
+  # to be an array, and if @is matches any of those values, then
+  # we consider it to be in-sync.
+  def insync?(is)
+    return true unless @should
+
+    self.devfail "#{self.class.name}'s should is not array" unless @should.is_a?(Array)
+
+    # an empty array is analogous to no should values
+    return true if @should.empty?
+
+    # Look for a matching value
+    return (is == @should or is == @should.collect { |v| v.to_s }) if match_all?
+
+    @should.each { |val| return true if is == val or is == val.to_s }
+
+    # otherwise, return false
+    false
+  end
+
+  # because the @should and @is vars might be in weird formats,
+  # we need to set up a mechanism for pretty printing of the values
+  # default to just the values, but this way individual properties can
+  # override these methods
+  def is_to_s(currentvalue)
+    currentvalue
+  end
+
+  # Send a log message.
+  def log(msg)
+
+          Puppet::Util::Log.create(
+                
+      :level => resource[:loglevel],
+      :message => msg,
+        
+      :source => self
+    )
+  end
+
+  # Should we match all values, or just the first?
+  def match_all?
+    self.class.array_matching == :all
+  end
+
+  # Execute our shadow's munge code, too, if we have one.
+  def munge(value)
+    self.shadow.munge(value) if self.shadow
+
+    super
+  end
+
+  # each property class must define the name method, and property instances
+  # do not change that name
+  # this implicitly means that a given object can only have one property
+  # instance of a given property class
+  def name
+    self.class.name
+  end
+
+  # for testing whether we should actually do anything
+  def noop
+    # This is only here to make testing easier.
+    if @resource.respond_to?(:noop?)
+      @resource.noop?
+    else
+      if defined?(@noop)
+        @noop
+      else
+        Puppet[:noop]
+      end
     end
-
-    # Set our value, using the provider, an associated block, or both.
-    def set(value)
-        # Set a name for looking up associated options like the event.
-        name = self.class.value_name(value)
-
-        call = self.class.value_option(name, :call) || :none
-
-        if call == :instead
-            event, tmp = call_valuemethod(name, value)
-        elsif call == :none
-            if @resource.provider
-                call_provider(value)
-            else
-                # They haven't provided a block, and our parent does not have
-                # a provider, so we have no idea how to handle this.
-                self.fail "%s cannot handle values of type %s" % [self.class.name, value.inspect]
-            end
-        else
-            # LAK:NOTE 20081031 This is a change in behaviour -- you could
-            # previously specify :call => [;before|:after], which would call
-            # the setter *in addition to* the block.  I'm convinced this
-            # was never used, and it makes things unecessarily complicated.
-            # If you want to specify a block and still call the setter, then
-            # do so in the block.
-            devfail "Cannot use obsolete :call value '%s' for property '%s'" % [call, self.class.name]
-        end
-
-        return event(name, event)
+  end
+
+  # By default, call the method associated with the property name on our
+  # provider.  In other words, if the property name is 'gid', we'll call
+  # 'provider.gid' to retrieve the current value.
+  def retrieve
+    provider.send(self.class.name)
+  end
+
+  # Set our value, using the provider, an associated block, or both.
+  def set(value)
+    # Set a name for looking up associated options like the event.
+    name = self.class.value_name(value)
+
+    call = self.class.value_option(name, :call) || :none
+
+    if call == :instead
+      call_valuemethod(name, value)
+    elsif call == :none
+      # They haven't provided a block, and our parent does not have
+      # a provider, so we have no idea how to handle this.
+      self.fail "#{self.class.name} cannot handle values of type #{value.inspect}" unless @resource.provider
+      call_provider(value)
+    else
+      # LAK:NOTE 20081031 This is a change in behaviour -- you could
+      # previously specify :call => [;before|:after], which would call
+      # the setter *in addition to* the block.  I'm convinced this
+      # was never used, and it makes things unecessarily complicated.
+      # If you want to specify a block and still call the setter, then
+      # do so in the block.
+      devfail "Cannot use obsolete :call value '#{call}' for property '#{self.class.name}'"
     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(:resource => self.resource)
-    end
-
-    # Only return the first value
-    def should
-        if defined? @should
-            unless @should.is_a?(Array)
-                self.devfail "should for %s on %s is not an array" %
-                    [self.class.name, @resource.name]
-            end
-            if match_all?
-                return @should.collect { |val| self.unmunge(val) }
-            else
-                return self.unmunge(@should[0])
-            end
-        else
-            return nil
-        end
+  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(:resource => self.resource)
+  end
+
+  # Only return the first value
+  def should
+    return nil unless defined?(@should)
+
+    self.devfail "should for #{self.class.name} on #{resource.name} is not an array" unless @should.is_a?(Array)
+
+    if match_all?
+      return @should.collect { |val| self.unmunge(val) }
+    else
+      return self.unmunge(@should[0])
     end
-
-    # Set the should value.
-    def should=(values)
-        unless values.is_a?(Array)
-            values = [values]
-        end
-
-        @shouldorig = values
-
-        values.each { |val| validate(val) }
-        @should = values.collect { |val| self.munge(val) }
-    end
-
-    def should_to_s(newvalue)
-        [newvalue].flatten.join(" ")
-    end
-
-    def sync
-        devfail "Got a nil value for should" unless should
-        set(should)
-    end
-
-    def to_s
-        return "%s(%s)" % [@resource.name,self.name]
-    end
-
-    # Verify that the passed value is valid.
-    # If the developer uses a 'validate' hook, this method will get overridden.
-    def unsafe_validate(value)
-        super
-        validate_features_per_value(value)
-    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(self.class.value_name(value), :required_features)
-            raise ArgumentError, "Provider must have features '%s' to set '%s' to '%s'" % [[features].flatten.join(", "), self.class.name, value] unless provider.satisfies?(features)
-        end
-    end
-
-    # Just return any should value we might have.
-    def value
-        self.should
-    end
-
-    # Match the Parameter interface, but we really just use 'should' internally.
-    # Note that the should= method does all of the validation and such.
-    def value=(value)
-        self.should = value
-    end
-
-    # This property will get automatically added to any type that responds
-    # to the methods 'exists?', 'create', and 'destroy'.
-    class Ensure < Puppet::Property
-        @name = :ensure
-
-        def self.defaultvalues
-            newvalue(:present) do
-                if @resource.provider and @resource.provider.respond_to?(:create)
-                    @resource.provider.create
-                else
-                    @resource.create
-                end
-                nil # return nil so the event is autogenerated
-            end
-
-            newvalue(:absent) do
-                if @resource.provider and @resource.provider.respond_to?(:destroy)
-                    @resource.provider.destroy
-                else
-                    @resource.destroy
-                end
-                nil # return nil so the event is autogenerated
-            end
-
-            defaultto do
-                if @resource.managed?
-                    :present
-                else
-                    nil
-                end
-            end
-
-            # This doc will probably get overridden
-            @doc ||= "The basic property that the resource should be in."
-        end
-
-        def self.inherited(sub)
-            # Add in the two properties that everyone will have.
-            sub.class_eval do
-            end
-        end
-
-        def change_to_s(currentvalue, newvalue)
-            begin
-                if currentvalue == :absent or currentvalue.nil?
-                    return "created"
-                elsif newvalue == :absent
-                    return "removed"
-                else
-                    return "%s changed '%s' to '%s'" %
-                        [self.name, self.is_to_s(currentvalue), self.should_to_s(newvalue)]
-                end
-            rescue Puppet::Error, Puppet::DevError
-                raise
-            rescue => detail
-                raise Puppet::DevError, "Could not convert change %s to string: %s" %
-                    [self.name, detail]
-            end
-        end
-
-        def retrieve
-            # XXX This is a problem -- whether the object exists or not often
-            # depends on the results of other properties, yet we're the first property
-            # to get checked, which means that those other properties do not have
-            # @is values set.  This seems to be the source of quite a few bugs,
-            # although they're mostly logging bugs, not functional ones.
-            if prov = @resource.provider and prov.respond_to?(:exists?)
-                result = prov.exists?
-            elsif @resource.respond_to?(:exists?)
-                result = @resource.exists?
-            else
-                raise Puppet::DevError, "No ability to determine if %s exists" %
-                    @resource.class.name
-            end
-            if result
-                return :present
-            else
-                return :absent
-            end
-        end
-
-        # If they're talking about the thing at all, they generally want to
-        # say it should exist.
-        #defaultto :present
-        defaultto do
-            if @resource.managed?
-                :present
-            else
-                nil
-            end
-        end
+  end
+
+  # Set the should value.
+  def should=(values)
+    values = [values] unless values.is_a?(Array)
+
+    @shouldorig = values
+
+    values.each { |val| validate(val) }
+    @should = values.collect { |val| self.munge(val) }
+  end
+
+  def should_to_s(newvalue)
+    [newvalue].flatten.join(" ")
+  end
+
+  def sync
+    devfail "Got a nil value for should" unless should
+    set(should)
+  end
+
+  # Verify that the passed value is valid.
+  # If the developer uses a 'validate' hook, this method will get overridden.
+  def unsafe_validate(value)
+    super
+    validate_features_per_value(value)
+  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(self.class.value_name(value), :required_features)
+      features = Array(features)
+      needed_features = features.collect { |f| f.to_s }.join(", ")
+      raise ArgumentError, "Provider must have features '#{needed_features}' to set '#{self.class.name}' to '#{value}'" unless provider.satisfies?(features)
     end
+  end
+
+  # Just return any should value we might have.
+  def value
+    self.should
+  end
+
+  # Match the Parameter interface, but we really just use 'should' internally.
+  # Note that the should= method does all of the validation and such.
+  def value=(value)
+    self.should = value
+  end
 end