puppet 4.2.0 → 4.3.0

data/lib/puppet/resource/capability_finder.rb

@@ -0,0 +1,95 @@
+#
+# A helper module to look a capability up from PuppetDB
+#
+# @todo lutter 2015-03-10: determine whether this should be based on
+# Puppet::Pops::Evaluator::Collectors, or at least use
+# Puppet::Util::Puppetdb::Http
+
+require 'net/http'
+require 'cgi'
+require 'json'
+
+# @api private
+module Puppet::Resource::CapabilityFinder
+
+  # Looks the capability resource from PuppetDB.
+  # @param environment [String] environment name
+  # @param code_id [String,nil] code_id of the catalog
+  # @param cap [Puppet::Type] the capability resource type instance
+  # @return [Puppet::Resource,nil] The found capability resource or `nil` if it could not be found
+  def self.find(environment, code_id, cap)
+    unless Puppet::Util.const_defined?('Puppetdb')
+      raise Puppet::DevError, 'PuppetDB is not available'
+    end
+
+    query_terms = [
+      'and',
+      ['=', 'type', cap.type.capitalize],
+      ['=', 'title', cap.title.to_s],
+      ['=', 'tag', "producer:#{environment}"]
+    ]
+
+    unless code_id.nil?
+      query_terms << ['in', 'certname',
+        ['extract', 'certname',
+          ['select_catalogs',
+            ['=', 'code_id', code_id]]]]
+    end
+    query = query_terms.to_json
+
+    Puppet.notice "Capability lookup #{cap}]: #{query}"
+
+    http = Puppet::Util.const_get('Puppetdb').const_get('Http')
+    response = http.action("/pdb/query/v4/resources?query=#{CGI.escape(query)}") do |conn, uri|
+      conn.get(uri, { 'Accept' => 'application/json'})
+    end
+    json = response.body
+
+    # The format of the response body is documented at
+    #   http://docs.puppetlabs.com/puppetdb/3.0/api/query/v4/resources.html#response-format
+    # In a nutshell, we expect to get an array of resources back. If the
+    # array is empty, the lookup failed and we return +nil+, if it
+    # contains exactly one, we turn that resource back into a Puppet
+    # ::Resource. If the array contains more than one entry, we have a
+    # bug in the overall system, as we allowed multiple capabilities with
+    # the same type and title to be produced in this environment.
+    begin
+      data = JSON.parse(json)
+    rescue JSON::JSONError => e
+      raise Puppet::DevError,
+      "Invalid JSON from PuppetDB when looking up #{cap}\n#{e}\nRaw JSON was:\n#{json}"
+    end
+    unless data.is_a?(Array)
+      raise Puppet::DevError,
+      "Unexpected response from PuppetDB when looking up #{cap}: " +
+        "expected an Array but got #{data.inspect}"
+    end
+    if data.size > 1
+      raise Puppet::DevError,
+      "Unexpected response from PuppetDB when looking up #{cap}:\n" +
+        "expected exactly one resource but got #{data.size};\n" +
+        "returned data is:\n#{data.inspect}"
+    end
+
+    unless data.empty?
+      resource_hash = data.first
+      resource = Puppet::Resource.new(resource_hash['type'],
+                                      resource_hash['title'])
+      real_type = Puppet::Type.type(resource.type)
+      if real_type.nil?
+        fail Puppet::ParseError,
+          "Could not find resource type #{resource.type} returned from PuppetDB"
+      end
+      real_type.parameters.each do |param|
+        param = param.to_s
+        next if param == 'name'
+        if value = resource_hash['parameters'][param]
+          resource[param] = value
+        else
+          Puppet.debug "No capability value for #{resource}->#{param}"
+        end
+      end
+      return resource
+    end
+  end
+end

data/lib/puppet/resource/catalog.rb

@@ -4,6 +4,8 @@ require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/graph'
 
+require 'puppet/resource/capability_finder'
+
 # This class models a node catalog.  It is the thing meant to be passed
 # from server to client, and it contains all of the information in the
 # catalog, including the resources and the relationships between them.
@@ -27,6 +29,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # is up to date.
   attr_accessor :version
 
+  # The id of the code input to the compiler.
+  attr_accessor :code_id
+
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
@@ -71,6 +76,25 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     return a
   end
 
+  def add_resource_before(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} before #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx)
+    end
+  end
+
+  def add_resource_after(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} after #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx+1)
+    end
+  end
+
+
   def add_resource(*resources)
     resources.each do |resource|
       add_one_resource(resource)
@@ -84,13 +108,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     adjacent(resource, :direction => :in)[0]
   end
 
-  def add_one_resource(resource)
+  def add_one_resource(resource, idx=-1)
     title_key = title_key_for_ref(resource.ref)
     if @resource_table[title_key]
       fail_on_duplicate_type_and_title(resource, title_key)
     end
 
-    add_resource_to_table(resource, title_key)
+    add_resource_to_table(resource, title_key, idx)
     create_resource_aliases(resource)
 
     resource.catalog = self if resource.respond_to?(:catalog=)
@@ -98,9 +122,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
   private :add_one_resource
 
-  def add_resource_to_table(resource, title_key)
+  def add_resource_to_table(resource, title_key, idx)
     @resource_table[title_key] = resource
-    @resources << title_key
+    @resources.insert(idx, title_key)
   end
   private :add_resource_to_table
 
@@ -245,7 +269,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     host_config
   end
 
-  def initialize(name = nil, environment = Puppet::Node::Environment::NONE)
+  def initialize(name = nil, environment = Puppet::Node::Environment::NONE, code_id = nil)
     super()
     @name = name
     @classes = []
@@ -256,6 +280,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     @host_config = true
     @environment_instance = environment
     @environment = environment.to_s
+    @code_id = code_id
 
     @aliases = {}
 
@@ -293,7 +318,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       @resources.delete(title_key)
-      resource.remove
+      # Only Puppet::Type kind of resources respond to :remove, not Puppet::Resource
+      resource.remove if resource.respond_to?(:remove)
     end
   end
 
@@ -313,7 +339,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     res.catalog = self
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key].flatten
-    @resource_table[title_key] || @resource_table[uniqueness_key]
+    result = @resource_table[title_key] || @resource_table[uniqueness_key]
+    if ! result && res.resource_type && res.resource_type.is_capability?
+      # @todo lutter 2015-03-10: this assumes that it is legal to just
+      # mention a capability resource in code and have it automatically
+      # made available, even if the current component does not require it
+      result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
+      add_resource(result) if result
+    end
+    result
   end
 
   def resource_refs
@@ -341,6 +375,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       result.version = version
     end
 
+    if code_id = data['code_id']
+      result.code_id = code_id
+    end
+
     if environment = data['environment']
       result.environment = environment
       result.environment_instance = Puppet::Node::Environment.remote(environment.to_sym)
@@ -381,6 +419,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       'tags'      => tags,
       'name'      => name,
       'version'   => version,
+      'code_id'   => code_id,
       'environment' => environment.to_s,
       'resources' => @resources.collect { |v| @resource_table[v].to_data_hash },
       'edges'     => edges.   collect { |e| e.to_data_hash },
@@ -496,6 +535,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result = self.class.new(self.name, self.environment_instance)
 
     result.version = self.version
+    result.code_id = self.code_id
 
     map = {}
     resources.each do |resource|

data/lib/puppet/resource/status.rb

@@ -1,6 +1,5 @@
 require 'time'
 require 'puppet/network/format_support'
-require 'puppet/util/psych_support'
 
 module Puppet
   class Resource
@@ -14,7 +13,6 @@ module Puppet
     class Status
       include Puppet::Util::Tagging
       include Puppet::Network::FormatSupport
-      include Puppet::Util::PsychSupport
 
       # @!attribute [rw] file
       #   @return [String] The file where `@real_resource` was defined.

data/lib/puppet/resource/type.rb

@@ -16,19 +16,40 @@ class Puppet::Resource::Type
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
-  RESOURCE_KINDS = [:hostclass, :node, :definition]
+  RESOURCE_KINDS = [:hostclass, :node, :definition, :capability_mapping, :application, :site]
 
   # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
       :hostclass => "class",
       :node => "node",
       :definition => "defined_type",
+      :application => "application",
+      :site => 'site'
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
+  NAME = 'name'.freeze
+  TITLE = 'title'.freeze
+  MODULE_NAME = 'module_name'.freeze
+  CALLER_MODULE_NAME = 'caller_module_name'.freeze
+  PARAMETERS = 'parameters'.freeze
+  KIND = 'kind'.freeze
+  NODES = 'nodes'.freeze
+  DOUBLE_COLON = '::'.freeze
+  EMPTY_ARRAY = [].freeze
+
   attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
+  # The attributes 'produces' and 'consumes' are arrays of the blueprints
+  # of capabilities this type can produce/consume. The entries in the array
+  # are a fairly direct representation of what goes into produces/consumes
+  # clauses. Each entry is a hash with attributes
+  #   :capability  - the type name of the capres produced/consumed
+  #   :mappings    - a hash of attribute_name => Expression
+  # These two attributes are populated in
+  # PopsBridge::instantiate_CapabilityMaping
+
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
   #
@@ -48,8 +69,8 @@ class Puppet::Resource::Type
   indirects :resource_type, :terminus_class => :parser
 
   def self.from_data_hash(data)
-    name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
-    kind = data.delete('kind') || "definition"
+    name = data.delete(NAME) or raise ArgumentError, 'Resource Type names must be specified'
+    kind = data.delete(KIND) || 'definition'
 
     unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
       raise ArgumentError, "Unsupported resource kind '#{kind}'"
@@ -74,15 +95,15 @@ class Puppet::Resource::Type
     # External documentation uses "parameters" but the internal name
     # is "arguments"
     # Dump any arguments as source
-    data['parameters'] = Hash[arguments.map do |k,v|
+    data[PARAMETERS] = Hash[arguments.map do |k,v|
                                 [k, v.respond_to?(:source_text) ? v.source_text : v]
                               end]
-    data['name'] = name
+    data[NAME] = name
 
     unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
       raise ArgumentError, "Unsupported resource kind '#{type}'"
     end
-    data['kind'] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
+    data[KIND] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
     data
   end
 
@@ -94,6 +115,48 @@ class Puppet::Resource::Type
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
+  # Evaluate the resources produced by the given resource. These resources are
+  # evaluated in a separate but identical scope from the rest of the resource.
+  def evaluate_produces(resource, scope)
+    # Only defined types and classes can produce capabilities
+    return unless definition? || hostclass?
+
+    resource.export.map do |ex|
+      # Assert that the ref really is a resource reference
+      raise Puppet::Error, "Invalid export in #{resource.ref}: #{ex} is not a resource" unless ex.is_a?(Puppet::Resource)
+      raise Puppet::Error, "Invalid export in #{resource.ref}: #{ex} is not a capability resource" if ex.resource_type.nil? || !ex.resource_type.is_capability?
+
+      blueprint = produces.find { |pr| pr[:capability] == ex.type }
+      if blueprint.nil?
+        raise Puppet::ParseError, "Resource type #{resource.type} does not produce #{ex.type}"
+      end
+      produced_resource = Puppet::Parser::Resource.new(ex.type, ex.title, :scope => scope, :source => self)
+
+      produced_resource.resource_type.parameters.each do |name|
+        next if name == :name
+
+        if expr = blueprint[:mappings][name.to_s]
+          produced_resource[name] = expr.safeevaluate(scope)
+        else
+          produced_resource[name] = scope[name.to_s]
+        end
+      end
+      # Tag the produced resource so we can later distinguish it from
+      # copies of the resource that wind up in the catalogs of nodes that
+      # use this resource. We tag the resource with producer:<environment>,
+      # meaning produced resources need to be unique within their
+      # environment
+      # @todo lutter 2014-11-13: we would really like to use a dedicated
+      # metadata field to indicate the producer of a resource, but that
+      # requires changes to PuppetDB and its API; so for now, we just use
+      # tagging
+      produced_resource.tag("producer:#{scope.catalog.environment}")
+      scope.catalog.add_resource(produced_resource)
+      produced_resource[:require] = resource.ref
+      produced_resource
+    end
+  end
+
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
 
@@ -107,6 +170,8 @@ class Puppet::Resource::Type
 
     resource.add_edge_to_stage
 
+    evaluate_produces(resource, scope)
+
     if code
       if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
         begin
@@ -132,7 +197,7 @@ class Puppet::Resource::Type
 
     [:code, :doc, :line, :file, :parent].each do |param|
       next unless value = options[param]
-      send(param.to_s + "=", value)
+      send(param.to_s + '=', value)
     end
 
     set_arguments(options[:arguments])
@@ -143,6 +208,24 @@ class Puppet::Resource::Type
     @module_name = options[:module_name]
   end
 
+  def produces
+    @produces || EMPTY_ARRAY
+  end
+
+  def consumes
+    @consumes || EMPTY_ARRAY
+  end
+
+  def add_produces(blueprint)
+    @produces ||= []
+    @produces << blueprint
+  end
+
+  def add_consumes(blueprint)
+    @consumes ||= []
+    @consumes << blueprint
+  end
+
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
@@ -186,8 +269,17 @@ class Puppet::Resource::Type
   # parameterized class, then all parameters take on their default
   # values.
   def ensure_in_catalog(scope, parameters=nil)
-    type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
-    resource_type = type == :hostclass ? :class : :node
+    resource_type =
+    case type
+    when :definition
+      raise ArgumentError, 'Cannot create resources for defined resource types'
+    when :hostclass
+      :class
+    when :node
+      :node
+    when :site
+      :site
+    end
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
@@ -196,11 +288,13 @@ class Puppet::Resource::Type
     # if parameters are passed, we should still try to create the resource
     # even if it exists so that we can fail
     # this prevents us from being able to combine param classes with include
-    if resource = scope.catalog.resource(resource_type, name) and !parameters
-      return resource
+    if parameters.nil?
+      resource = scope.catalog.resource(resource_type, name)
+      return resource unless resource.nil?
+    elsif parameters.is_a?(Hash)
+      parameters = parameters.map {|k, v| Puppet::Parser::Resource::Param.new(:name => k, :value => v, :source => self)}
     end
-    resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
-    assign_parameter_values(parameters, resource)
+    resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self, :parameters => parameters)
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
@@ -229,7 +323,11 @@ class Puppet::Resource::Type
     @name.is_a?(Regexp)
   end
 
+  # @deprecated Not used by Puppet
+  # @api private
   def assign_parameter_values(parameters, resource)
+    Puppet.deprecation_warning('The method Puppet::Resource::Type.assign_parameter_values is deprecated and will be removed in the next major release of Puppet.')
+
     return unless parameters
 
     # It'd be nice to assign default parameter values here,
@@ -247,53 +345,91 @@ class Puppet::Resource::Type
       fail(Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}")
   end
 
-  # Set any arguments passed by the resource as variables in the scope.
+  # Validate and set any arguments passed by the resource as variables in the scope.
+  # @param resource [Puppet::Parser::Resource] the resource
+  # @param scope [Puppet::Parser::Scope] the scope
+  #
+  # @api private
   def set_resource_parameters(resource, scope)
-    set = {}
-    resource.to_hash.each do |param, value|
-      param = param.to_sym
-      fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
+    # Inject parameters from using external lookup
+    resource.add_parameters_from_consume
+    inject_external_parameters(resource, scope)
 
-      exceptwrap { scope[param.to_s] = value }
-
-      set[param] = true
-    end
+    resource_hash = {}
+    resource.each { |k, v| resource_hash[k.to_s] = v.value unless k == :name || k == :title }
 
     if @type == :hostclass
-      scope["title"] = resource.title.to_s.downcase unless set.include? :title
-      scope["name"] =  resource.name.to_s.downcase  unless set.include? :name
+      scope[TITLE] = resource.title.to_s.downcase
+      scope[NAME] =  resource.name.to_s.downcase
     else
-      scope["title"] = resource.title               unless set.include? :title
-      scope["name"] =  resource.name                unless set.include? :name
+      scope[TITLE] = resource.title
+      scope[NAME] =  resource.name
     end
-    scope["module_name"] = module_name if module_name and ! set.include? :module_name
 
-    if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
-      scope["caller_module_name"] = caller_name
+    modname = resource_hash[MODULE_NAME] || module_name
+    scope[MODULE_NAME] = modname unless modname.nil?
+    caller_name = resource_hash[CALLER_MODULE_NAME] || scope.parent_module_name
+    scope[CALLER_MODULE_NAME] = caller_name unless caller_name.nil?
+
+    scope.class_set(self.name,scope) if hostclass? || node?
+
+    assign_defaults(resource, scope, resource_hash)
+    validate_resource_hash(resource, resource_hash)
+    resource_hash.each { |param, value| exceptwrap { scope[param] = value }}
+  end
+
+  # Lookup and inject parameters from external scope
+  # @param resource [Puppet::Parser::Resource] the resource
+  # @param scope [Puppet::Parser::Scope] the scope
+  def inject_external_parameters(resource, scope)
+    # Only lookup parameters for host classes
+    return unless type == :hostclass
+    parameters = resource.parameters
+    arguments.each do |param_name, _|
+      name = param_name.to_sym
+      next if parameters.include?(name)
+      value = lookup_external_default_for(param_name, scope)
+      resource[name] = value unless value.nil?
+    end
+  end
+  private :inject_external_parameters
+
+  def assign_defaults(resource, scope, resource_hash)
+    return unless resource.is_a?(Puppet::Parser::Resource)
+    parameters = resource.parameters
+    hashed_types = parameter_struct.hashed_elements
+    arguments.each do |param_name, default|
+      next if default.nil?
+      name = param_name.to_sym
+      param = parameters[name]
+      next unless param.nil? || param.value.nil?
+
+      value = default.safeevaluate(scope)
+      resource[name] = value
+      resource_hash[param_name] = value
     end
-    scope.class_set(self.name,scope) if hostclass? or node?
+  end
+  private :assign_defaults
 
-    # Evaluate the default parameters, now that all other variables are set
-    default_params = resource.set_default_parameters(scope)
-    default_params.each { |param| scope[param] = resource[param] }
+  def validate_resource_hash(resource, resource_hash)
+    Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(resource.to_s, parameter_struct, resource_hash, resource.is_unevaluated_consumer?)
+  end
+  private :validate_resource_hash
 
-    # This has to come after the above parameters so that default values
-    # can use their values
-    resource.validate_complete
+  # Validate that all parameters given to the resource are correct
+  # @param resource [Puppet::Resource] the resource to validate
+  def validate_resource(resource)
+    validate_resource_hash(resource, Hash[resource.parameters.map { |name, value| [name.to_s, value.value] }])
   end
 
   # Check whether a given argument is valid.
   def valid_parameter?(param)
-    param = param.to_s
-
-    return true if param == "name"
-    return true if Puppet::Type.metaparam?(param)
-    return false unless defined?(@arguments)
-    return(arguments.include?(param) ? true : false)
+    parameter_struct.hashed_elements.include?(param.to_s)
   end
 
   def set_arguments(arguments)
     @arguments = {}
+    @parameter_struct = nil
     return if arguments.nil?
 
     arguments.each do |arg, default|
@@ -309,6 +445,7 @@ class Puppet::Resource::Type
   #
   def set_argument_types(name_to_type_hash)
     @argument_types = {}
+    @parameter_struct = nil
     return unless name_to_type_hash
     name_to_type_hash.each do |name, t|
       # catch internal errors
@@ -322,6 +459,14 @@ class Puppet::Resource::Type
     end
   end
 
+  # Returns boolean true if an instance of this type is a capability. This
+  # implementation always returns false. This "duck-typing" interface is
+  # shared among other classes and makes it easier to detect capabilities
+  # when they are intermixed with non capability instances.
+  def is_capability?
+    false
+  end
+
   private
 
   def convert_from_ast(name)
@@ -341,9 +486,9 @@ class Puppet::Resource::Type
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
-    ary = fullname.split("::")
+    ary = fullname.split(DOUBLE_COLON)
     n = ary.pop || ""
-    ns = ary.join("::")
+    ns = ary.join(DOUBLE_COLON)
     return ns, n
   end
 
@@ -374,4 +519,53 @@ class Puppet::Resource::Type
       raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
     end
   end
+
+  def parameter_struct
+    @parameter_struct ||= create_params_struct
+  end
+
+  def create_params_struct
+    arg_types = argument_types
+    type_factory = Puppet::Pops::Types::TypeFactory
+    members = { type_factory.optional(type_factory.string(nil, NAME)) =>  type_factory.any }
+
+    if application?
+      resource_type = type_factory.type_type(type_factory.resource)
+      members[type_factory.optional(type_factory.string(nil, NODES))] = type_factory.hash_of(type_factory.variant(
+          resource_type, type_factory.array_of(resource_type)), type_factory.type_type(type_factory.resource('node')))
+    end
+
+    Puppet::Type.eachmetaparam do |name|
+      # TODO: Once meta parameters are typed, this should change to reflect that type
+      members[name.to_s] = type_factory.any
+    end
+
+    arguments.each_pair do |name, default|
+      key_type = type_factory.string(nil, name.to_s)
+      key_type = type_factory.optional(key_type) unless default.nil?
+
+      arg_type = arg_types[name]
+      arg_type = type_factory.any if arg_type.nil?
+      members[key_type] = arg_type
+    end
+    type_factory.struct(members)
+  end
+  private :create_params_struct
+
+  # Consult external data bindings for class parameter values which must be
+  # namespaced in the backend.
+  #
+  # Example:
+  #
+  #   class foo($port=0){ ... }
+  #
+  # We make a request to the backend for the key 'foo::port' not 'foo'
+  #
+  def lookup_external_default_for(param, scope)
+    if type == :hostclass
+      catch(:no_such_key) { return Puppet::Pops::Lookup.search_and_merge("#{name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil) }
+    end
+    nil
+  end
+  private :lookup_external_default_for
 end