puppet 6.16.0-x86-mingw32 → 7.0.0-x86-mingw32

data/lib/puppet/provider/service/windows.rb

@@ -14,29 +14,28 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
   defaultfor :operatingsystem => :windows
   confine    :operatingsystem => :windows
 
-  has_feature :refreshable
-  has_feature :configurable_timeout
+  has_feature :refreshable, :configurable_timeout, :manages_logon_credentials
 
   def enable
-    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_AUTO_START )
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {startup_type: :SERVICE_AUTO_START})
   rescue => detail
     raise Puppet::Error.new(_("Cannot enable %{resource_name}, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def disable
-    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_DISABLED )
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {startup_type: :SERVICE_DISABLED})
   rescue => detail
     raise Puppet::Error.new(_("Cannot disable %{resource_name}, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def manual_start
-    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_DEMAND_START )
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {startup_type: :SERVICE_DEMAND_START})
   rescue => detail
     raise Puppet::Error.new(_("Cannot enable %{resource_name} for manual start, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
 
   def delayed_start
-    Puppet::Util::Windows::Service.set_startup_mode( @resource[:name], :SERVICE_AUTO_START, true )
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {startup_type: :SERVICE_AUTO_START, delayed: true})
   rescue => detail
     raise Puppet::Error.new(_("Cannot enable %{resource_name} for delayed start, error was: %{detail}") % { resource_name: @resource[:name], detail: detail }, detail )
   end
@@ -110,7 +109,10 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
         raise Puppet::Error.new(_("Unknown service state '%{current_state}' for service '%{resource_name}'") % { current_state: current_state, resource_name: @resource[:name] })
     end
     debug("Service #{@resource[:name]} is #{current_state}")
-    return state
+    state
+  rescue => detail
+    Puppet.warning("Status for service #{@resource[:name]} could not be retrieved: #{detail}")
+    :stopped
   end
 
   def default_timeout
@@ -125,4 +127,18 @@ Puppet::Type.type(:service).provide :windows, :parent => :service do
     end
     services
   end
+
+  def logonaccount
+    return unless Puppet::Util::Windows::Service.exists?(@resource[:name])
+    Puppet::Util::Windows::Service.logon_account(@resource[:name])
+  end
+
+  def logonaccount=(value)
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {logon_account: value, logon_password: @resource[:logonpassword]})
+    restart if @resource[:ensure] == :running && [:running, :paused].include?(status)
+  end
+
+  def logonpassword=(value)
+    Puppet::Util::Windows::Service.set_startup_configuration(@resource[:name], options: {logon_password: value})
+  end
 end

data/lib/puppet/provider/user/aix.rb

@@ -288,7 +288,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   # UNSUPPORTED
   #- **roles**
   #    The roles the user has.  Multiple roles should be
-  #    specified as an array.  Requires features manages_solaris_rbac.
+  #    specified as an array.  Requires features manages_roles.
   # UNSUPPORTED
   #- **key_membership**
   #    Whether specified key value pairs should be treated as the only

data/lib/puppet/provider/user/directoryservice.rb

@@ -657,14 +657,4 @@ Puppet::Type.type(:user).provide :directoryservice do
   def write_users_plist_to_disk(users_plist)
     Puppet::Util::Plist.write_plist_file(users_plist, "#{users_plist_dir}/#{@resource.name}.plist", :binary)
   end
-
-  # This is a simple wrapper method for writing values to a file.
-  def write_to_file(filename, value)
-    Puppet.deprecation_warning("Puppet::Type.type(:user).provider(:directoryservice).write_to_file is deprecated and will be removed in Puppet 5.")
-    begin
-      File.open(filename, 'w') { |f| f.write(value)}
-    rescue Errno::EACCES => detail
-      raise Puppet::Error, "Could not write to file #{filename}: #{detail}", detail.backtrace
-    end
-  end
 end

data/lib/puppet/provider/user/user_role_add.rb

@@ -33,7 +33,7 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
     set("shell", value)
   end
 
-  has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_passwords, :manages_password_age, :manages_shell
+  has_features :manages_homedir, :allows_duplicates, :manages_solaris_rbac, :manages_roles, :manages_passwords, :manages_password_age, :manages_shell
 
   def check_valid_shell
     unless File.exist?(@resource.should(:shell))

data/lib/puppet/provider/user/useradd.rb

@@ -138,10 +138,17 @@ Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameServ
 
   def check_manage_home
     cmd = []
-    if @resource.managehome? && (!@resource.forcelocal?)
-      cmd << "-m"
-    elsif (!@resource.managehome?) && Facter.value(:osfamily) == 'RedHat'
-      cmd << "-M"
+    if @resource.managehome?
+      # libuser does not implement the -m flag
+      cmd << "-m" unless @resource.forcelocal?
+    else
+      osfamily = Facter.value(:osfamily)
+      osversion = Facter.value(:operatingsystemmajrelease).to_i
+      # SLES 11 uses pwdutils instead of shadow, which does not have -M
+      # Solaris and OpenBSD use different useradd flavors
+      unless osfamily =~ /Solaris|OpenBSD/ || osfamily == 'Suse' && osversion <= 11
+        cmd << "-M"
+      end
     end
     cmd
   end

data/lib/puppet/provider/user/windows_adsi.rb

@@ -6,7 +6,7 @@ Puppet::Type.type(:user).provide :windows_adsi do
   defaultfor :operatingsystem => :windows
   confine    :operatingsystem => :windows
 
-  has_features :manages_homedir, :manages_passwords
+  has_features :manages_homedir, :manages_passwords, :manages_roles
 
   def initialize(value={})
     super(value)
@@ -17,6 +17,23 @@ Puppet::Type.type(:user).provide :windows_adsi do
     @user ||= Puppet::Util::Windows::ADSI::User.new(@resource[:name])
   end
 
+  def roles
+    Puppet::Util::Windows::User::get_rights(@resource[:name])
+  end
+
+  def roles=(value)
+    current = roles.split(',')
+    should  = value.split(',')
+
+    add_list = should - current
+    Puppet::Util::Windows::User::set_rights(@resource[:name], add_list) unless add_list.empty?
+
+    if @resource[:role_membership] == :inclusive
+      remove_list = current - should
+      Puppet::Util::Windows::User::remove_rights(@resource[:name], remove_list) unless remove_list.empty?
+    end
+  end
+
   def groups
     @groups ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(user.groups)
     @groups.keys

data/lib/puppet/reference/configuration.rb

@@ -24,6 +24,8 @@ config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc
     val = object.default
     if name.to_s == 'vardir'
       val = 'Unix/Linux: /opt/puppetlabs/puppet/cache -- Windows: C:\ProgramData\PuppetLabs\puppet\cache -- Non-root user: ~/.puppetlabs/opt/puppet/cache'
+    elsif name.to_s == 'publicdir'
+      val = 'Unix/Linux: /opt/puppetlabs/puppet/public -- Windows: C:\ProgramData\PuppetLabs\puppet\public -- Non-root user: ~/.puppetlabs/opt/puppet/public'
     elsif name.to_s == 'confdir'
       val = 'Unix/Linux: /etc/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\etc -- Non-root user: ~/.puppetlabs/etc/puppet'
     elsif name.to_s == 'codedir'

data/lib/puppet/reference/indirection.rb

@@ -46,7 +46,7 @@ An indirector has five methods, which are mapped into HTTP verbs for the REST in
 
 These methods are available via the `indirection` class method on the indirected classes.  For example:
 
-    foo_cert = Puppet::SSL::Certificate.indirection.find('foo.example.com')
+    node = Puppet::Node.indirection.find('foo.example.com')
 
 At startup, each indirection is configured with a terminus.
 In most cases, this is the default terminus defined by the indirected class, but it can be overridden by the application or face, or overridden with the `route_file` configuration.

data/lib/puppet/reports/http.rb

@@ -25,6 +25,8 @@ Puppet::Reports.register_report(:http) do
       :include_system_store => Puppet[:report_include_system_store],
     }
 
+    # Puppet's http client implementation accepts userinfo in the URL
+    # but puppetserver's does not. So pass credentials explicitly.
     if url.user && url.password
       options[:basic_auth] = {
         user: url.user,

data/lib/puppet/resource.rb

@@ -32,7 +32,6 @@ class Puppet::Resource
   ATTRIBUTES = [:file, :line, :exported].freeze
   TYPE_CLASS = 'Class'.freeze
   TYPE_NODE  = 'Node'.freeze
-  TYPE_SITE  = 'Site'.freeze
 
   PCORE_TYPE_KEY = '__ptype'.freeze
   VALUE_KEY = 'value'.freeze
@@ -340,29 +339,6 @@ class Puppet::Resource
     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.nil? && 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
@@ -377,12 +353,11 @@ class Puppet::Resource
     case type
     when TYPE_CLASS; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when TYPE_NODE; environment.known_resource_types.node(title)
-    when TYPE_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)
+        result = krt.definition(type)
       end
       result
     end
@@ -515,38 +490,6 @@ class Puppet::Resource
   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 %{resource} - not a parser resource") % { resource: self }
-    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
@@ -555,37 +498,6 @@ class Puppet::Resource
     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 %{resource}") % { param: param, resource: 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|
-      t = arg_types[name.to_s] # untyped, and parameters are symbols here (aargh, strings in the type)
-      next unless t
-      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 '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s }
-      end
-    end
-  end
-
   def validate_parameter(name)
     raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name)
   end
@@ -628,7 +540,8 @@ class Puppet::Resource
   def self.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.nil? && argtype.is_a?(String) &&
+          argtype =~ /^([^\[\]]+)\[(.+)\]$/m                   then [ $1,                 $2            ]
     elsif argtitle                                             then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
     else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect }

data/lib/puppet/resource/catalog.rb

@@ -5,8 +5,6 @@ require 'puppet/util/tagging'
 require 'puppet/graph'
 require 'securerandom'
 
-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.
@@ -382,23 +380,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result = @resource_table[title_key]
     if result.nil?
       # an instance has to be created in order to construct the unique key used when
-      # searching for aliases, or nothing is found as it is needed by the CapabilityFinder.
+      # searching for aliases
       res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
 
       # Must check with uniqueness key because of aliases or if resource transforms title in title
       # to attribute mappings.
       result = @resource_table[[type_name, res.uniqueness_key].flatten]
-
-      if result.nil?
-        resource_type = res.resource_type
-        if resource_type && 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
-      end
     end
     result
   end

data/lib/puppet/resource/type.rb

@@ -11,15 +11,13 @@ class Puppet::Resource::Type
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
-  RESOURCE_KINDS = [:hostclass, :node, :definition, :capability_mapping, :application, :site]
+  RESOURCE_KINDS = [:hostclass, :node, :definition]
 
   # 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'
+      :definition => "defined_type"
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
@@ -33,18 +31,9 @@ class Puppet::Resource::Type
   DOUBLE_COLON = '::'.freeze
   EMPTY_ARRAY = [].freeze
 
-  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
+  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection, :override
   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_CapabilityMapping
-
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
   #
@@ -62,56 +51,12 @@ class Puppet::Resource::Type
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
+    return true if override
     return false unless parent
 
     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 %{reference}: %{ex} is not a resource") % { reference: resource.ref, ex: ex } unless ex.is_a?(Puppet::Resource)
-      raise Puppet::Error, _("Invalid export in %{reference}: %{ex} is not a capability resource") % { reference: resource.ref, ex: ex } 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 %{res_type} does not produce %{ex_type}") % { res_type: resource.type, ex_type: ex.type }
-      end
-      t = ex.type
-      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
-      produced_resource = Puppet::Parser::Resource.new(t, ex.title, :scope => scope, :source => self)
-
-      produced_resource.resource_type.parameters.each do |name|
-        next if name == :name
-
-        expr = blueprint[:mappings][name.to_s]
-        if expr
-          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)
 
@@ -125,8 +70,6 @@ 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
         scope.with_guarded_scope do
@@ -161,24 +104,6 @@ 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)
@@ -234,8 +159,6 @@ class Puppet::Resource::Type
       :class
     when :node
       :node
-    when :site
-      :site
     end
 
     # Do nothing if the resource already exists; this makes sure we don't
@@ -280,21 +203,6 @@ 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,
-    # but we can't because they often rely on local variables
-    # created during set_resource_parameters.
-    parameters.each do |name, value|
-      resource.set_parameter name, value
-    end
-  end
-
   def parent_type(scope = nil)
     return nil unless parent
 
@@ -317,7 +225,6 @@ class Puppet::Resource::Type
     caller_name = resource[:caller_module_name] || scope.parent_module_name
     scope[CALLER_MODULE_NAME] = caller_name unless caller_name.nil?
 
-    resource.add_parameters_from_consume
     inject_external_parameters(resource, scope)
 
     if @type == :hostclass
@@ -380,7 +287,7 @@ class Puppet::Resource::Type
   private :assign_defaults
 
   def validate_resource_hash(resource, resource_hash)
-    Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(resource.to_s, parameter_struct, resource_hash, resource.is_unevaluated_consumer?)
+    Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(resource.to_s, parameter_struct, resource_hash, false)
   end
   private :validate_resource_hash
 
@@ -435,14 +342,6 @@ 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)
@@ -507,12 +406,6 @@ class Puppet::Resource::Type
     type_factory = Puppet::Pops::Types::TypeFactory
     members = { type_factory.optional(type_factory.string(NAME)) =>  type_factory.any }
 
-    if application?
-      resource_type = type_factory.type_type(type_factory.resource)
-      members[type_factory.string(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