puppet 4.4.0-universal-darwin

data/lib/puppet/relationship.rb

@@ -0,0 +1,90 @@
+# subscriptions are permanent associations determining how different
+# objects react to an event
+
+# This is Puppet's class for modeling edges in its configuration graph.
+# It used to be a subclass of GRATR::Edge, but that class has weird hash
+# overrides that dramatically slow down the graphing.
+class Puppet::Relationship
+
+  # FormatSupport for serialization methods
+  include Puppet::Network::FormatSupport
+
+  attr_accessor :source, :target, :callback
+
+  attr_reader :event
+
+  def self.from_data_hash(data)
+    source = data["source"]
+    target = data["target"]
+
+    args = {}
+    if event = data["event"]
+      args[:event] = event
+    end
+    if callback = data["callback"]
+      args[:callback] = callback
+    end
+
+    new(source, target, args)
+  end
+
+  def event=(event)
+    raise ArgumentError, "You must pass a callback for non-NONE events" if event != :NONE and ! callback
+    @event = event
+  end
+
+  def initialize(source, target, options = {})
+    @source, @target = source, target
+
+    options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
+    [:callback, :event].each do |option|
+      if value = options[option]
+        send(option.to_s + "=", value)
+      end
+    end
+  end
+
+  # Does the passed event match our event?  This is where the meaning
+  # of :NONE comes from.
+  def match?(event)
+    if self.event.nil? or event == :NONE or self.event == :NONE
+      return false
+    elsif self.event == :ALL_EVENTS or event == self.event
+      return true
+    else
+      return false
+    end
+  end
+
+  def label
+    result = {}
+    result[:callback] = callback if callback
+    result[:event] = event if event
+    result
+  end
+
+  def ref
+    "#{source} => #{target}"
+  end
+
+  def inspect
+    "{ #{source} => #{target} }"
+  end
+
+  def to_data_hash
+    data = {
+      'source' => source.to_s,
+      'target' => target.to_s
+    }
+
+    ["event", "callback"].each do |attr|
+      next unless value = send(attr)
+      data[attr] = value
+    end
+    data
+  end
+
+  def to_s
+    ref
+  end
+end

data/lib/puppet/reports.rb

@@ -0,0 +1,93 @@
+require 'puppet/util/instance_loader'
+
+# This class is an implementation of a simple mechanism for loading and returning reports.
+# The intent is that a user registers a report by calling {register_report} and providing a code
+# block that performs setup, and defines a method called `process`. The setup, and the `process` method
+# are called in the context where `self` is an instance of {Puppet::Transaction::Report} which provides the actual
+# data for the report via its methods.
+#
+# @example Minimal scaffolding for a report...
+#   Puppet::Reports::.register_report(:myreport) do
+#     # do setup here
+#     def process
+#       if self.status == 'failed'
+#         msg = "failed puppet run for #{self.host} #{self.status}"
+#         . . .
+#       else
+#         . . .
+#       end
+#     end
+#   end
+#
+# Required configuration:
+# --
+# * A .rb file that defines a new report should be placed in the master's directory `lib/puppet/reports`
+# * The `puppet.conf` file must have `report = true` in the `[agent]` section
+#
+# @see Puppet::Transaction::Report
+# @api public
+#
+class Puppet::Reports
+  extend Puppet::Util::ClassGen
+  extend Puppet::Util::InstanceLoader
+
+  # Set up autoloading and retrieving of reports.
+  instance_load :report, 'puppet/reports'
+
+  class << self
+    # @api private
+    attr_reader :hooks
+  end
+
+  # Adds a new report type.
+  # The block should contain setup, and define a method with the name `process`. The `process` method is
+  # called when the report is executed; the `process` method has access to report data via methods available
+  # in its context where `self` is an instance of {Puppet::Transaction::Report}.
+  #
+  # For an example, see the overview of this class.
+  #
+  # @param name [Symbol] the name of the report (do not use whitespace in the name).
+  # @param options [Hash] a hash of options
+  # @option options [Boolean] :useyaml whether yaml should be used or not
+  # @todo Uncertain what the options :useyaml really does; "whether yaml should be used or not", used where/how?
+  #
+  def self.register_report(name, options = {}, &block)
+    name = name.intern
+
+    mod = genmodule(name,
+                    :extend    => Puppet::Util::Docs,
+                    :hash      => instance_hash(:report),
+                    :overwrite => true,
+                    :block     => block)
+
+    mod.useyaml = true if options[:useyaml]
+
+    mod.send(:define_method, :report_name) do
+      name
+    end
+  end
+
+  # Collects the docs for all reports.
+  # @api private
+  def self.reportdocs
+    docs = ""
+
+    # Use this method so they all get loaded
+    instance_loader(:report).loadall
+    loaded_instances(:report).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+      mod = self.report(name)
+      docs << "#{name}\n#{"-" * name.to_s.length}\n"
+
+      docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
+    end
+
+    docs
+  end
+
+  # Lists each of the reports.
+  # @api private
+  def self.reports
+    instance_loader(:report).loadall
+    loaded_instances(:report)
+  end
+end

data/lib/puppet/reports/http.rb

@@ -0,0 +1,31 @@
+require 'puppet'
+require 'puppet/network/http_pool'
+require 'uri'
+
+Puppet::Reports.register_report(:http) do
+
+  desc <<-DESC
+    Send reports via HTTP or HTTPS. This report processor submits reports as
+    POST requests to the address in the `reporturl` setting. The body of each POST
+    request is the YAML dump of a Puppet::Transaction::Report object, and the
+    Content-Type is set as `application/x-yaml`.
+  DESC
+
+  def process
+    url = URI.parse(Puppet[:reporturl])
+    headers = { "Content-Type" => "application/x-yaml" }
+    options = {}
+    if url.user && url.password
+      options[:basic_auth] = {
+        :user => url.user,
+        :password => url.password
+      }
+    end
+    use_ssl = url.scheme == 'https'
+    conn = Puppet::Network::HttpPool.http_instance(url.host, url.port, use_ssl)
+    response = conn.post(url.path, self.to_yaml, headers, options)
+    unless response.kind_of?(Net::HTTPSuccess)
+      Puppet.err "Unable to submit report to #{Puppet[:reporturl].to_s} [#{response.code}] #{response.msg}"
+    end
+  end
+end

data/lib/puppet/reports/log.rb

@@ -0,0 +1,14 @@
+require 'puppet/reports'
+
+Puppet::Reports.register_report(:log) do
+  desc "Send all received logs to the local log destinations.  Usually
+    the log destination is syslog."
+
+  def process
+    self.logs.each do |log|
+      log.source = "//#{self.host}/#{log.source}"
+      Puppet::Util::Log.newmessage(log)
+    end
+  end
+end
+

data/lib/puppet/reports/store.rb

@@ -0,0 +1,68 @@
+require 'puppet'
+require 'fileutils'
+require 'puppet/util'
+
+SEPARATOR = [Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join
+
+Puppet::Reports.register_report(:store) do
+  desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
+    and this just stores the file on disk, in the `reportdir` directory.
+
+    These files collect quickly -- one every half hour -- so it is a good idea
+    to perform some maintenance on them if you use this report (it's the only
+    default report)."
+
+  def process
+    validate_host(host)
+
+    dir = File.join(Puppet[:reportdir], host)
+
+    if ! Puppet::FileSystem.exist?(dir)
+      FileUtils.mkdir_p(dir)
+      FileUtils.chmod_R(0750, dir)
+    end
+
+    # Now store the report.
+    now = Time.now.gmtime
+    name = %w{year month day hour min}.collect do |method|
+      # Make sure we're at least two digits everywhere
+      "%02d" % now.send(method).to_s
+    end.join("") + ".yaml"
+
+    file = File.join(dir, name)
+
+    begin
+      Puppet::Util.replace_file(file, 0640) do |fh|
+        fh.print to_yaml
+      end
+    rescue => detail
+       Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
+    end
+
+    # Only testing cares about the return value
+    file
+  end
+
+  # removes all reports for a given host?
+  def self.destroy(host)
+    validate_host(host)
+
+    dir = File.join(Puppet[:reportdir], host)
+
+    if Puppet::FileSystem.exist?(dir)
+      Dir.entries(dir).each do |file|
+        next if ['.','..'].include?(file)
+        file = File.join(dir, file)
+        Puppet::FileSystem.unlink(file) if File.file?(file)
+      end
+      Dir.rmdir(dir)
+    end
+  end
+
+  def validate_host(host)
+    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
+      raise ArgumentError, "Invalid node name #{host.inspect}"
+    end
+  end
+  module_function :validate_host
+end

data/lib/puppet/resource.rb

@@ -0,0 +1,606 @@
+require 'puppet'
+require 'puppet/util/tagging'
+require 'puppet/parameter'
+require 'puppet/data_providers'
+
+# The simplest resource class.  Eventually it will function as the
+# base class for all resource-like behaviour.
+#
+# @api public
+class Puppet::Resource
+  include Puppet::Util::Tagging
+
+  include Enumerable
+  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
+  attr_reader :type, :title
+
+  # @deprecated
+  attr_accessor :validate_parameters
+
+  require 'puppet/indirector'
+  extend Puppet::Indirector
+  indirects :resource, :terminus_class => :ral
+
+  ATTRIBUTES = [:file, :line, :exported]
+
+  def self.from_data_hash(data)
+    raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
+    raise ArgumentError, "No resource title provided in serialized data" unless title = data['title']
+
+    resource = new(type, title)
+
+    if params = data['parameters']
+      params.each { |param, value| resource[param] = value }
+    end
+
+    if tags = data['tags']
+      tags.each { |tag| resource.tag(tag) }
+    end
+
+    ATTRIBUTES.each do |a|
+      if value = data[a.to_s]
+        resource.send(a.to_s + "=", value)
+      end
+    end
+
+    resource
+  end
+
+  def inspect
+    "#{@type}[#{@title}]#{to_hash.inspect}"
+  end
+
+  def to_data_hash
+    data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
+      next hash unless value = self.send(param)
+      hash[param.to_s] = value
+      hash
+    end
+
+    data["exported"] ||= false
+
+    params = self.to_hash.inject({}) do |hash, ary|
+      param, value = ary
+
+      # Don't duplicate the title as the namevar
+      next hash if param == namevar and value == title
+
+      hash[param] = Puppet::Resource.value_to_pson_data(value)
+      hash
+    end
+
+    data["parameters"] = params unless params.empty?
+
+    data
+  end
+
+  def self.value_to_pson_data(value)
+    if value.is_a? Array
+      value.map{|v| value_to_pson_data(v) }
+    elsif value.is_a? Puppet::Resource
+      value.to_s
+    else
+      value
+    end
+  end
+
+  def yaml_property_munge(x)
+    case x
+    when Hash
+      x.inject({}) { |h,kv|
+        k,v = kv
+        h[k] = self.class.value_to_pson_data(v)
+        h
+      }
+    else self.class.value_to_pson_data(x)
+    end
+  end
+
+  YAML_ATTRIBUTES = [:@file, :@line, :@exported, :@type, :@title, :@tags, :@parameters]
+
+  # Explicitly list the instance variables that should be serialized when
+  # converting to YAML.
+  #
+  # @api private
+  # @return [Array<Symbol>] The intersection of our explicit variable list and
+  #   all of the instance variables defined on this class.
+  def to_yaml_properties
+    YAML_ATTRIBUTES & super
+  end
+
+  # Proxy these methods to the parameters hash.  It's likely they'll
+  # be overridden at some point, but this works for now.
+  %w{has_key? keys length delete empty? <<}.each do |method|
+    define_method(method) do |*args|
+      parameters.send(method, *args)
+    end
+  end
+
+  # Set a given parameter.  Converts all passed names
+  # to lower-case symbols.
+  def []=(param, value)
+    validate_parameter(param) if validate_parameters
+    parameters[parameter_name(param)] = value
+  end
+
+  # Return a given parameter's value.  Converts all passed names
+  # to lower-case symbols.
+  def [](param)
+    parameters[parameter_name(param)]
+  end
+
+  def ==(other)
+    return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
+
+    return false unless to_hash == other.to_hash
+    true
+  end
+
+  # Compatibility method.
+  def builtin?
+    builtin_type?
+  end
+
+  # Is this a builtin resource type?
+  def builtin_type?
+    resource_type.is_a?(Class)
+  end
+
+  # Iterate over each param/value pair, as required for Enumerable.
+  def each
+    parameters.each { |p,v| yield p, v }
+  end
+
+  def include?(parameter)
+    super || parameters.keys.include?( parameter_name(parameter) )
+  end
+
+  %w{exported virtual strict}.each do |m|
+    define_method(m+"?") do
+      self.send(m)
+    end
+  end
+
+  def class?
+    @is_class ||= @type == "Class"
+  end
+
+  def stage?
+    @is_stage ||= @type.to_s.downcase == "stage"
+  end
+
+  # Construct a resource from data.
+  #
+  # Constructs a resource instance with the given `type` and `title`. Multiple
+  # type signatures are possible for these arguments and most will result in an
+  # expensive call to {Puppet::Node::Environment#known_resource_types} in order
+  # to resolve `String` and `Symbol` Types to actual Ruby classes.
+  #
+  # @param type [Symbol, String] The name of the Puppet Type, as a string or
+  #   symbol. The actual Type will be looked up using
+  #   {Puppet::Node::Environment#known_resource_types}. This lookup is expensive.
+  # @param type [String] The full resource name in the form of
+  #   `"Type[Title]"`. This method of calling should only be used when
+  #   `title` is `nil`.
+  # @param type [nil] If a `nil` is passed, the title argument must be a string
+  #   of the form `"Type[Title]"`.
+  # @param type [Class] A class that inherits from `Puppet::Type`. This method
+  #   of construction is much more efficient as it skips calls to
+  #   {Puppet::Node::Environment#known_resource_types}.
+  #
+  # @param title [String, :main, nil] The title of the resource. If type is `nil`, may also
+  #   be the full resource name in the form of `"Type[Title]"`.
+  #
+  # @api public
+  def initialize(type, title = nil, attributes = {})
+    @parameters = {}
+    if type.is_a?(Puppet::Resource)
+      # Copy constructor. Let's avoid munging, extracting, tagging, etc
+      src = type
+      self.file = src.file
+      self.line = src.line
+      self.exported = src.exported
+      self.virtual = src.virtual
+      self.set_tags(src)
+      self.environment = src.environment
+      @rstype = src.resource_type
+      @type = src.type
+      @title = src.title
+
+      src.to_hash.each do |p, v|
+        if v.is_a?(Puppet::Resource)
+          v = Puppet::Resource.new(v.type, v.title)
+        elsif v.is_a?(Array)
+          # flatten resource references arrays
+          v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
+          v = v.collect do |av|
+            av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
+            av
+          end
+        end
+
+        self[p] = v
+      end
+    else
+      environment = attributes[:environment]
+      if type.is_a?(Class) && type < Puppet::Type
+        # Set the resource type to avoid an expensive `known_resource_types`
+        # lookup.
+        self.resource_type = type
+        # From this point on, the constructor behaves the same as if `type` had
+        # been passed as a symbol.
+        type = type.name
+      end
+
+      # Set things like strictness first.
+      attributes.each do |attr, value|
+        next if attr == :parameters
+        send(attr.to_s + "=", value)
+      end
+
+      @type, @title = extract_type_and_title(type, title)
+
+      @type = munge_type_name(@type)
+
+      if self.class?
+        @title = :main if @title == ""
+        @title = munge_type_name(@title)
+      end
+
+      if params = attributes[:parameters]
+        extract_parameters(params)
+      end
+
+    	if resource_type && resource_type.respond_to?(:deprecate_params)
+        resource_type.deprecate_params(title, attributes[:parameters])
+    	end
+
+      tag(self.type)
+      tag_if_valid(self.title)
+    end
+
+    if strict? and ! resource_type
+      if self.class?
+        raise ArgumentError, "Could not find declared class #{title}"
+      else
+        raise ArgumentError, "Invalid resource type #{type}"
+      end
+    end
+  end
+
+  def ref
+    to_s
+  end
+
+  # Find our resource.
+  def resolve
+    catalog ? catalog.resource(to_s) : nil
+  end
+
+  # A resource is an application component if it exports or consumes
+  # one or more capabilities, or if it requires a capability resource
+  def is_application_component?
+    return true if ! export.empty? || self[:consume]
+    # Array(self[:require]) does not work for Puppet::Resource instances
+    req = self[:require] || []
+    req = [ req ] unless req.is_a?(Array)
+    req.any? { |r| r.is_capability? }
+  end
+
+  # A resource is a capability (instance) if its underlying type is a
+  # capability type
+  def is_capability?
+    resource_type and resource_type.is_capability?
+  end
+
+  # Returns the value of the 'export' metaparam as an Array
+  # @api private
+  def export
+    v = self[:export] || []
+    v.is_a?(Array) ? v : [ v ]
+  end
+
+  # The resource's type implementation
+  # @return [Puppet::Type, Puppet::Resource::Type]
+  # @api private
+  def resource_type
+    @rstype ||= case type
+    when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
+    when "Node"; environment.known_resource_types.node(title)
+    when "Site"; environment.known_resource_types.site(nil)
+    else
+      result = Puppet::Type.type(type)
+      if !result
+        krt = environment.known_resource_types
+        result = krt.definition(type) || krt.application(type)
+      end
+      result
+    end
+  end
+
+  # Set the resource's type implementation
+  # @param type [Puppet::Type, Puppet::Resource::Type]
+  # @api private
+  def resource_type=(type)
+    @rstype = type
+  end
+
+  def environment
+    @environment ||= if catalog
+                       catalog.environment_instance
+                     else
+                       Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE }
+                     end
+  end
+
+  def environment=(environment)
+    @environment = environment
+  end
+
+  # Produce a simple hash of our parameters.
+  def to_hash
+    parse_title.merge parameters
+  end
+
+  def to_s
+    "#{type}[#{title}]"
+  end
+
+  def uniqueness_key
+    # Temporary kludge to deal with inconsistent use patterns; ensure we don't return nil for namevar/:name
+    h = self.to_hash
+    name = h[namevar] || h[:name] || self.name
+    h[namevar] ||= name
+    h[:name]   ||= name
+    h.values_at(*key_attributes.sort_by { |k| k.to_s })
+  end
+
+  def key_attributes
+    resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
+  end
+
+  # Convert our resource to yaml for Hiera purposes.
+  def to_hierayaml
+    # Collect list of attributes to align => and move ensure first
+    attr = parameters.keys
+    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+
+    attr.sort!
+    if attr.first != :ensure  && attr.include?(:ensure)
+      attr.delete(:ensure)
+      attr.unshift(:ensure)
+    end
+
+    attributes = attr.collect { |k|
+      v = parameters[k]
+      "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
+    }.join
+
+    "  %s:\n%s" % [self.title, attributes]
+  end
+
+  # Convert our resource to Puppet code.
+  def to_manifest
+    # Collect list of attributes to align => and move ensure first
+    attr = parameters.keys
+    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+
+    attr.sort!
+    if attr.first != :ensure  && attr.include?(:ensure)
+      attr.delete(:ensure)
+      attr.unshift(:ensure)
+    end
+
+    attributes = attr.collect { |k|
+      v = parameters[k]
+      "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
+    }.join
+
+    escaped = self.title.gsub(/'/,"\\\\'")
+    "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes]
+  end
+
+  def to_ref
+    ref
+  end
+
+  # Convert our resource to a RAL resource instance.  Creates component
+  # instances for resource types that don't exist.
+  def to_ral
+    typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+    typeklass.new(self)
+  end
+
+  def name
+    # this is potential namespace conflict
+    # between the notion of an "indirector name"
+    # and a "resource name"
+    [ type, title ].join('/')
+  end
+
+  def missing_arguments
+    resource_type.arguments.select do |param, default|
+      the_param = parameters[param.to_sym]
+      the_param.nil? || the_param.value.nil? || the_param.value == :undef
+    end
+  end
+  private :missing_arguments
+
+  # @deprecated Not used by Puppet
+  # @api private
+  def set_default_parameters(scope)
+    Puppet.deprecation_warning('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.')
+
+    return [] unless resource_type and resource_type.respond_to?(:arguments)
+
+    unless is_a?(Puppet::Parser::Resource)
+      fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
+    end
+
+    missing_arguments.collect do |param, default|
+      rtype = resource_type
+      if rtype.type == :hostclass
+        using_bound_value = false
+        catch(:no_such_key) do
+          bound_value = Puppet::Pops::Lookup.search_and_merge("#{rtype.name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil)
+          # Assign bound value but don't let an undef trump a default expression
+          unless bound_value.nil? && !default.nil?
+            self[param.to_sym] = bound_value
+            using_bound_value = true
+          end
+        end
+      end
+      unless using_bound_value
+        next if default.nil?
+        self[param.to_sym] = default.safeevaluate(scope)
+      end
+      param
+    end.compact
+  end
+
+  def copy_as_resource
+    Puppet::Resource.new(self)
+  end
+
+  def valid_parameter?(name)
+    resource_type.valid_parameter?(name)
+  end
+
+  # Verify that all required arguments are either present or
+  # have been provided with defaults.
+  # Must be called after 'set_default_parameters'.  We can't join the methods
+  # because Type#set_parameters needs specifically ordered behavior.
+  #
+  # @deprecated Not used by Puppet
+  # @api private
+  def validate_complete
+    Puppet.deprecation_warning('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.')
+
+    return unless resource_type and resource_type.respond_to?(:arguments)
+
+    resource_type.arguments.each do |param, default|
+      param = param.to_sym
+      fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
+    end
+
+    # Perform optional type checking
+    arg_types = resource_type.argument_types
+    # Parameters is a map from name, to parameter, and the parameter again has name and value
+    parameters.each do |name, value|
+      next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
+      unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
+        inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
+        actual = inferred_type.generalize()
+        fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
+      end
+    end
+  end
+
+  def validate_parameter(name)
+    raise Puppet::ParseError.new("no parameter named '#{name}'", file, line) unless valid_parameter?(name)
+  end
+
+  def prune_parameters(options = {})
+    properties = resource_type.properties.map(&:name)
+
+    dup.collect do |attribute, value|
+      if value.to_s.empty? or Array(value).empty?
+        delete(attribute)
+      elsif value.to_s == "absent" and attribute.to_s != "ensure"
+        delete(attribute)
+      end
+
+      parameters_to_include = options[:parameters_to_include] || []
+      delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
+    end
+    self
+  end
+
+  private
+
+  # Produce a canonical method name.
+  def parameter_name(param)
+    param = param.to_s.downcase.to_sym
+    if param == :name and namevar
+      param = namevar
+    end
+    param
+  end
+
+  # The namevar for our resource type. If the type doesn't exist,
+  # always use :name.
+  def namevar
+    if builtin_type? and t = resource_type and t.key_attributes.length == 1
+      t.key_attributes.first
+    else
+      :name
+    end
+  end
+
+  def extract_parameters(params)
+    params.each do |param, value|
+      validate_parameter(param) if strict?
+      self[param] = value
+    end
+  end
+
+  def extract_type_and_title(argtype, argtitle)
+    if    (argtype.nil? || argtype == :component || argtype == :whit) &&
+           argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                 then [ $1,                 $2            ]
+    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
+    elsif argtitle                                             then [ argtype,            argtitle      ]
+    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
+    elsif argtype.is_a?(Hash)                                  then
+      raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
+        "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
+    else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
+    end
+  end
+
+  def munge_type_name(value)
+    return :main if value == :main
+    return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
+
+    value.to_s.split("::").collect { |s| s.capitalize }.join("::")
+  end
+
+  def parse_title
+    h = {}
+    type = resource_type
+    if type.respond_to? :title_patterns
+      type.title_patterns.each { |regexp, symbols_and_lambdas|
+        if captures = regexp.match(title.to_s)
+          symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
+            symbol, proc = symbol_and_lambda
+            # Many types pass "identity" as the proc; we might as well give
+            # them a shortcut to delivering that without the extra cost.
+            #
+            # Especially because the global type defines title_patterns and
+            # uses the identity patterns.
+            #
+            # This was worth about 8MB of memory allocation saved in my
+            # testing, so is worth the complexity for the API.
+            if proc then
+              h[symbol] = proc.call(capture)
+            else
+              h[symbol] = capture
+            end
+          end
+          return h
+        end
+      }
+      # If we've gotten this far, then none of the provided title patterns
+      # matched. Since there's no way to determine the title then the
+      # resource should fail here.
+      raise Puppet::Error, "No set of title patterns matched the title \"#{title}\"."
+    else
+      return { :name => title.to_s }
+    end
+  end
+
+  def parameters
+    # @parameters could have been loaded from YAML, causing it to be nil (by
+    # bypassing initialize).
+    @parameters ||= {}
+  end
+end