puppet-resource_api 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c26bda3effbce092aa8b8defb8904fdb41a02231fba2830593bfc85413b66906
-  data.tar.gz: 89b49840bd21ea57227db05021e0b9ddb7ab7539b9b130a888e3fea99b7da87e
+  metadata.gz: '066920a9f1eca6ad946f2c8f39239482a2d00b756a9ac26db2441c4015a6aa37'
+  data.tar.gz: b9f87949cc263e98ead6d3fc5dcc480787a8122078e548bb135a2f1c21373f30
 SHA512:
-  metadata.gz: 971775219d3ae76f94a18ebef57b0a1be470a0c222b31a4a1cf0d1d4b8f4ecc71516fb6b004674a4878c619d97f4b6f3e644edcc43e3cba419070afd5ad53bd3
-  data.tar.gz: dfb2823ce573240977587f9a7431b1956a62a0367a740d4e0c9fc412436542d41065be88e7ed8348057fd42b1cf039c4ac69c8e4b7bad7f4771d73c2f6927454
+  metadata.gz: c61a6bc59301a6214c53470b213d59493a31056f20b02ab6f6688ee9809f3f0a05494b66e8c2c0daa28fb222af85f132867a4b1164121ac1aa4f184d60a2acda
+  data.tar.gz: 393f017b70985894eb1f5abe4ecd0ec41d6640bd5d57fa288fb2a66acfc202dcb42b1c11fda89ec1e4c694a688442555015465a8e4ffd6354150da59f245faae

data/.rubocop.yml

@@ -1,6 +1,5 @@
 ---
 require: rubocop-rspec
-inherit_from: .rubocop_todo.yml
 AllCops:
   TargetRubyVersion: '2.1'
   Include:
@@ -157,4 +156,4 @@ Naming/UncommunicativeMethodParamName:
 
 # This cop breaks syntax highlighting in VSCode
 Layout/ClosingHeredocIndentation:
-  Enabled: false
+  Enabled: false

data/.travis.yml

@@ -25,7 +25,7 @@ matrix:
     - env: RVM="jruby-9.1.9.0" PUPPET_GEM_VERSION='~> 5' JRUBY_OPTS="--debug"
       before_cache: pushd ~/.rvm && rm -rf archives rubies/ruby-2.2.7 rubies/ruby-2.3.4 && popd
       cache:
-        bundler: true
+        bundler: false
         directories: ~/.rvm
       before_install: rvm use jruby-9.1.9.0 --install --binary --fuzzy
     - rvm: 2.4.3
@@ -65,10 +65,5 @@ matrix:
     - rvm: 2.5.1
       env: PUPPET_GEM_VERSION='https://github.com/puppetlabs/puppet.git#6.0.x'
 notifications:
-  hipchat:
-    rooms:
-      secure: 10a49kkZcghKHNnef8x7eBG+KjScL3i1VpygFg6DPAOK2YNbEoyEx1Kv9KLC7GSRYov/SQZOsZrvHZtDhEtFSKhhiAjOwxl1jV1t6aAMGMnN1IoZBOvdAJKrZsm54/bBeYp+je2wqnnoFNtLVFSoOX0LkFaDEWT+zGZ5xKJIH25GpeQEZf1eDxs/d8YX/m+RwbGXHVA//hOpvZo0ntvznh2EbW5OPODKSeUXbWZ+W4ndODTsKWFc/WLMSSgFDzW/Y2/9V40D4IC8lvSx6eKFryMfAQy6pO/d1aTB468awzyVcdYAMMCOITm7hlKGRKxNgq6NkOsXs5KLg6ifpn+a/Rhapbz6Qxbpjjho/7Wxngl4B3T+i35ap/mFrS/fOfKCq3gEQlYn29its9bEFArNGbr+/sXKABb+sRpgW4RTPWYDHJyHJendbevd5tZ+fd0JUBOi0Cb4PcXxQxM8IQrbuu2zso0K5MV05kL0S1DE/VsuUrPaK0RsF+b1+i6NfvtN8kgbYs1eiVku+guIG2ec3xIefQ1hsEOFPFNqSDfHp7nANnRVIbBCt8qw8DhmNEczsfN5Dp21euJUsO9qpau++NzD3jRhkE5Zki5cwsakU7hIQzw82BIb0eSQJCHygieExeEboWRqtDgy/IKIWPgIvEuU68ppR2bl2reKCHLCnWc=
-    template:
-    - '%{repository}#%{build_number} (%{branch} - %{commit} : %{author}): %{message}
-      (<a href="%{build_url}">Details</a> | <a href="%{compare_url}">PR/Diff</a>)'
-    format: html
+  slack:
+    secure: aPXZYNow8LsmmlS8PQU3FjL0bc7FqUUA95d++wZfIu7YAjGboIUiekxYouQ0XnY+Aig8InvbTOIgBHgGNheyr/YFbFS90/jtulbF8oW7BitW+imgjeAHDCwlQZTCc4FFYde/2pI7QTT8H5NpLR9mKxlTU77Sqr8gFAIybuPdHcKMYQZdEZS07ma2pUp7+GyKS6PDQpzW2+mDCz/wfi3/JdsUvc0mclCZ8vxySc66j5P1E6nFDMzuakBOjwJHpgeDpreapbmSUQLAX0a3ZsFP+N+SNduLotlV2BWnJK2gcO6rGFP4Fz1D0bGXuBnYYdIiB+9OgI3wtXg9y1SifNHUG3IrOBAA8CGNyrebTGKtH0TS2O+HZLbaNX2g6udD5e3156vys9wScmJuQ/rSkVtQfXf1qUm5eijvlXI+DIbssbZHqm6QQGyM4p3NoULmNmF1C85bQoZ4GF7b1P/8mstsVE/HUfnzRPNbwD0r6j1aE/ck3PKMi7ZAhIi0Ja9RnAgP3wi0t62uERYcJGGYEycWohMWnrf2w6GFwGeuoiwAkASdHOLX0/AOMPc4mBOjlc621o8uYMrrZqfF5CrOAvJ151USSsWn2AhXaibIvnHo6X91paNvvNpU/GYu3CUAl6q8OhYovvjtRVPVnhs2DrpgoRB+6NWHnzjRG/wr6Z9U+vA=

data/CHANGELOG.md

@@ -3,6 +3,57 @@
 All significant changes to this repo will be summarized in this file.
 
 
+## [v1.8.0](https://github.com/puppetlabs/puppet-resource_api/tree/v1.8.0) (2019-02-26)
+[Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.7.0...v1.8.0)
+
+**Implemented enhancements:**
+
+- \(FM-7695\) Transports - the remote content framework [\#157](https://github.com/puppetlabs/puppet-resource_api/pull/157) ([DavidS](https://github.com/DavidS))
+- \(FM-7698\) implement `sensitive:true` handling [\#156](https://github.com/puppetlabs/puppet-resource_api/pull/156) ([da-ar](https://github.com/da-ar))
+- \(PDK-1271\) Allow a transport to be wrapped and used like a device [\#155](https://github.com/puppetlabs/puppet-resource_api/pull/155) ([da-ar](https://github.com/da-ar))
+- \(FM-7701\) Support device providers when using Transport Wrapper [\#154](https://github.com/puppetlabs/puppet-resource_api/pull/154) ([da-ar](https://github.com/da-ar))
+- \(FM-7726\) implement `context.transport` to provide access [\#152](https://github.com/puppetlabs/puppet-resource_api/pull/152) ([DavidS](https://github.com/DavidS))
+- \(FM-7674\) Allow wrapping a Transport in a legacy Device [\#149](https://github.com/puppetlabs/puppet-resource_api/pull/149) ([da-ar](https://github.com/da-ar))
+- \(FM-7600\) Add Transport.connect method [\#148](https://github.com/puppetlabs/puppet-resource_api/pull/148) ([da-ar](https://github.com/da-ar))
+
+**Fixed bugs:**
+
+- \(FM-7690\) Fix transports cache to be environment aware [\#151](https://github.com/puppetlabs/puppet-resource_api/pull/151) ([da-ar](https://github.com/da-ar))
+
+**Merged pull requests:**
+
+- \(FM-7726\) cleanups for the transport  [\#153](https://github.com/puppetlabs/puppet-resource_api/pull/153) ([DavidS](https://github.com/DavidS))
+- \(FM-7691,FM-7696\) refactoring definition handling in contexts [\#150](https://github.com/puppetlabs/puppet-resource_api/pull/150) ([DavidS](https://github.com/DavidS))
+
+## [v1.7.0](https://github.com/puppetlabs/puppet-resource_api/tree/v1.7.0) (2019-01-07)
+[Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.6.3...v1.7.0)
+
+**Implemented enhancements:**
+
+- \(maint\) Validate Type Schema [\#142](https://github.com/puppetlabs/puppet-resource_api/pull/142) ([da-ar](https://github.com/da-ar))
+
+**Merged pull requests:**
+
+- \(maint\) Bundler 2.0 dropped support for Ruby versions \< 2.2 [\#147](https://github.com/puppetlabs/puppet-resource_api/pull/147) ([da-ar](https://github.com/da-ar))
+-  \(FM-7597\) RSAPI Transport register function [\#146](https://github.com/puppetlabs/puppet-resource_api/pull/146) ([da-ar](https://github.com/da-ar))
+- \(packaging\) Update version to 1.7.0 [\#144](https://github.com/puppetlabs/puppet-resource_api/pull/144) ([branan](https://github.com/branan))
+
+## [v1.6.3](https://github.com/puppetlabs/puppet-resource_api/tree/v1.6.3) (2018-12-11)
+[Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.6.2...v1.6.3)
+
+**Closed issues:**
+
+- Trying to understand stubbing in the examples [\#136](https://github.com/puppetlabs/puppet-resource_api/issues/136)
+
+**Merged pull requests:**
+
+- \(packaging\) Update version to 1.6.3 [\#143](https://github.com/puppetlabs/puppet-resource_api/pull/143) ([branan](https://github.com/branan))
+- Move parameter and property logic to separate classes [\#140](https://github.com/puppetlabs/puppet-resource_api/pull/140) ([bpietraga](https://github.com/bpietraga))
+- \(maint\) Predeclare Puppet module before ResourceApi [\#139](https://github.com/puppetlabs/puppet-resource_api/pull/139) ([caseywilliams](https://github.com/caseywilliams))
+- \(maint\) minor fix to make data\_type\_handling change work [\#138](https://github.com/puppetlabs/puppet-resource_api/pull/138) ([DavidS](https://github.com/DavidS))
+- \(maint\) extract data type handling code [\#137](https://github.com/puppetlabs/puppet-resource_api/pull/137) ([bpietraga](https://github.com/bpietraga))
+- Release prep for v1.6.2 [\#135](https://github.com/puppetlabs/puppet-resource_api/pull/135) ([DavidS](https://github.com/DavidS))
+
 ## [v1.6.2](https://github.com/puppetlabs/puppet-resource_api/tree/v1.6.2) (2018-10-25)
 [Full Changelog](https://github.com/puppetlabs/puppet-resource_api/compare/v1.6.1...v1.6.2)
 

data/lib/puppet/resource_api.rb

@@ -5,12 +5,15 @@ require 'puppet/resource_api/parameter'
 require 'puppet/resource_api/property'
 require 'puppet/resource_api/puppet_context' unless RUBY_PLATFORM == 'java'
 require 'puppet/resource_api/read_only_parameter'
+require 'puppet/resource_api/transport'
+require 'puppet/resource_api/transport/wrapper'
 require 'puppet/resource_api/type_definition'
 require 'puppet/resource_api/value_creator'
 require 'puppet/resource_api/version'
 require 'puppet/type'
 require 'puppet/util/network_device'
 
+# This module contains the main API to register and access types, providers and transports.
 module Puppet::ResourceApi
   @warning_count = 0
 
@@ -38,7 +41,12 @@ module Puppet::ResourceApi
       # Keeps a copy of the provider around. Weird naming to avoid clashes with puppet's own `provider` member
       define_singleton_method(:my_provider) do
         @my_provider ||= Hash.new { |hash, key| hash[key] = Puppet::ResourceApi.load_provider(definition[:name]).new }
-        @my_provider[Puppet::Util::NetworkDevice.current.class]
+
+        if Puppet::Util::NetworkDevice.current.is_a? Puppet::ResourceApi::Transport::Wrapper
+          @my_provider[Puppet::Util::NetworkDevice.current.transport.class]
+        else
+          @my_provider[Puppet::Util::NetworkDevice.current.class]
+        end
       end
 
       # make the provider available in the instance's namespace
@@ -352,7 +360,7 @@ MESSAGE
       end
 
       define_singleton_method(:context) do
-        @context ||= PuppetContext.new(definition)
+        @context ||= PuppetContext.new(TypeDefinition.new(definition))
       end
 
       def context
@@ -410,8 +418,10 @@ MESSAGE
     type_name_sym = type_name.to_sym
     device_name = if Puppet::Util::NetworkDevice.current.nil?
                     nil
-                  else
+                  elsif Puppet::Util::NetworkDevice.current.is_a? Puppet::ResourceApi::Transport::Wrapper
                     # extract the device type from the currently loaded device's class
+                    Puppet::Util::NetworkDevice.current.schema.name
+                  else
                     Puppet::Util::NetworkDevice.current.class.name.split('::')[-2].downcase
                   end
     device_class_name = class_name_from_type_name(device_name)
@@ -451,6 +461,12 @@ MESSAGE
   end
   module_function :load_device_provider # rubocop:disable Style/AccessModifierDeclarations
 
+  # keeps the existing register API format. e.g. Puppet::ResourceApi.register_type
+  def register_transport(schema)
+    Puppet::ResourceApi::Transport.register(schema)
+  end
+  module_function :register_transport # rubocop:disable Style/AccessModifierDeclarations
+
   def self.class_name_from_type_name(type_name)
     type_name.to_s.split('_').map(&:capitalize).join
   end

data/lib/puppet/resource_api/base_context.rb

@@ -1,20 +1,34 @@
 require 'puppet/resource_api/type_definition'
 
+# rubocop:disable Style/Documentation
 module Puppet; end
 module Puppet::ResourceApi; end
+# rubocop:enable Style/Documentation
+
+# This class provides access to all common external dependencies of providers and transports.
+# The runtime environment will inject an appropriate implementation.
 class Puppet::ResourceApi::BaseContext
   attr_reader :type
 
   def initialize(definition)
-    raise ArgumentError, 'BaseContext requires definition to be a Hash' unless definition.is_a?(Hash)
-    @typename = definition[:name]
-    @type = Puppet::ResourceApi::TypeDefinition.new(definition)
+    if definition.is_a?(Hash)
+      # this is only for backwards compatibility
+      @type = Puppet::ResourceApi::TypeDefinition.new(definition)
+    elsif definition.is_a? Puppet::ResourceApi::BaseTypeDefinition
+      @type = definition
+    else
+      raise ArgumentError, 'BaseContext requires definition to be a child of Puppet::ResourceApi::BaseTypeDefinition, not <%{actual_type}>' % { actual_type: definition.class }
+    end
   end
 
   def device
     raise 'Received device() on an unprepared BaseContext. Use a PuppetContext instead.'
   end
 
+  def transport
+    raise 'No transport available.'
+  end
+
   def failed?
     @failed
   end
@@ -27,7 +41,7 @@ class Puppet::ResourceApi::BaseContext
   [:debug, :info, :notice, :warning, :err].each do |level|
     define_method(level) do |*args|
       if args.length == 1
-        message = "#{@context || @typename}: #{args.last}"
+        message = "#{@context || @type.name}: #{args.last}"
       elsif args.length == 2
         resources = format_titles(args.first)
         message = "#{resources}: #{args.last}"
@@ -137,9 +151,9 @@ class Puppet::ResourceApi::BaseContext
 
   def format_titles(titles)
     if titles.length.zero? && !titles.is_a?(String)
-      @typename
+      @type.name
     else
-      "#{@typename}[#{[titles].flatten.compact.join(', ')}]"
+      "#{@type.name}[#{[titles].flatten.compact.join(', ')}]"
     end
   end
 

data/lib/puppet/resource_api/io_context.rb

@@ -1,9 +1,14 @@
 require 'puppet/resource_api/base_context'
 
+# Implement Resource API Conext to log through an IO object, defaulting to `$stderr`.
+# There is no access to a device here. You can supply a transport if necessary.
 class Puppet::ResourceApi::IOContext < Puppet::ResourceApi::BaseContext
-  def initialize(definition, target = $stderr)
+  attr_reader :transport
+
+  def initialize(definition, target = $stderr, transport = nil)
     super(definition)
     @target = target
+    @transport = transport
   end
 
   protected

data/lib/puppet/resource_api/puppet_context.rb

@@ -1,6 +1,8 @@
 require 'puppet/resource_api/base_context'
 require 'puppet/util/logging'
 
+# Implement Resource API Context to log through Puppet facilities
+# and access/expose the puppet process' current device/transport
 class Puppet::ResourceApi::PuppetContext < Puppet::ResourceApi::BaseContext
   def device
     # TODO: evaluate facter_url setting for loading config if there is no `current` NetworkDevice
@@ -8,6 +10,10 @@ class Puppet::ResourceApi::PuppetContext < Puppet::ResourceApi::BaseContext
     Puppet::Util::NetworkDevice.current
   end
 
+  def transport
+    device.transport
+  end
+
   def log_exception(exception, message: 'Error encountered', trace: false)
     super(exception, message: message, trace: trace || Puppet[:trace])
   end

data/lib/puppet/resource_api/transport.rb

@@ -0,0 +1,95 @@
+module Puppet::ResourceApi; end # rubocop:disable Style/Documentation
+
+# Remote target transport API
+module Puppet::ResourceApi::Transport
+  def register(schema)
+    raise Puppet::DevError, 'requires a hash as schema, not `%{other_type}`' % { other_type: schema.class } unless schema.is_a? Hash
+    raise Puppet::DevError, 'requires a `:name`' unless schema.key? :name
+    raise Puppet::DevError, 'requires `:desc`' unless schema.key? :desc
+    raise Puppet::DevError, 'requires `:connection_info`' unless schema.key? :connection_info
+    raise Puppet::DevError, '`:connection_info` must be a hash, not `%{other_type}`' % { other_type: schema[:connection_info].class } unless schema[:connection_info].is_a?(Hash)
+
+    init_transports
+    unless @transports[@environment][schema[:name]].nil?
+      raise Puppet::DevError, 'Transport `%{name}` is already registered for `%{environment}`' % {
+        name: schema[:name],
+        environment: @environment,
+      }
+    end
+    @transports[@environment][schema[:name]] = Puppet::ResourceApi::TransportSchemaDef.new(schema)
+  end
+  module_function :register # rubocop:disable Style/AccessModifierDeclarations
+
+  # retrieve a Hash of transport schemas, keyed by their name.
+  def list
+    init_transports
+    Marshal.load(Marshal.dump(@transports[@environment]))
+  end
+  module_function :list # rubocop:disable Style/AccessModifierDeclarations
+
+  def connect(name, connection_info)
+    validate(name, connection_info)
+    require "puppet/transport/#{name}"
+    class_name = name.split('_').map { |e| e.capitalize }.join
+    Puppet::Transport.const_get(class_name).new(get_context(name), wrap_sensitive(name, connection_info))
+  end
+  module_function :connect # rubocop:disable Style/AccessModifierDeclarations
+
+  def inject_device(name, transport)
+    transport_wrapper = Puppet::ResourceApi::Transport::Wrapper.new(name, transport)
+
+    if Puppet::Util::NetworkDevice.respond_to?(:set_device)
+      Puppet::Util::NetworkDevice.set_device(name, transport_wrapper)
+    else
+      Puppet::Util::NetworkDevice.instance_variable_set(:@current, transport_wrapper)
+    end
+  end
+  module_function :inject_device # rubocop:disable Style/AccessModifierDeclarations
+
+  def self.validate(name, connection_info)
+    init_transports
+    require "puppet/transport/schema/#{name}" unless @transports[@environment].key? name
+    transport_schema = @transports[@environment][name]
+    if transport_schema.nil?
+      raise Puppet::DevError, 'Transport for `%{target}` not registered with `%{environment}`' % {
+        target: name,
+        environment: @environment,
+      }
+    end
+    message_prefix = 'The connection info provided does not match the Transport Schema'
+    transport_schema.check_schema(connection_info, message_prefix)
+    transport_schema.validate(connection_info)
+  end
+  private_class_method :validate
+
+  def self.get_context(name)
+    require 'puppet/resource_api/puppet_context'
+    Puppet::ResourceApi::PuppetContext.new(@transports[@environment][name])
+  end
+  private_class_method :get_context
+
+  def self.init_transports
+    lookup = Puppet.lookup(:current_environment) if Puppet.respond_to? :lookup
+    @environment =  if lookup.nil?
+                      :transports_default
+                    else
+                      lookup.name
+                    end
+    @transports ||= {}
+    @transports[@environment] ||= {}
+  end
+  private_class_method :init_transports
+
+  def self.wrap_sensitive(name, connection_info)
+    transport_schema = @transports[@environment][name]
+    if transport_schema
+      transport_schema.definition[:connection_info].each do |attr_name, options|
+        if options.key?(:sensitive) && (options[:sensitive] == true)
+          connection_info[attr_name] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(connection_info[attr_name])
+        end
+      end
+    end
+    connection_info
+  end
+  private_class_method :wrap_sensitive
+end

data/lib/puppet/resource_api/transport/wrapper.rb

@@ -0,0 +1,55 @@
+require 'puppet/resource_api/transport'
+require 'hocon'
+require 'hocon/config_syntax'
+
+# Puppet::ResourceApi::Transport::Wrapper` to interface between the Util::NetworkDevice
+class Puppet::ResourceApi::Transport::Wrapper
+  attr_reader :transport, :schema
+
+  def initialize(name, url_or_config_or_transport)
+    if url_or_config_or_transport.is_a? String
+      url = URI.parse(url_or_config_or_transport)
+      raise "Unexpected url '#{url_or_config_or_transport}' found. Only file:/// URLs for configuration supported at the moment." unless url.scheme == 'file'
+      raise "Trying to load config from '#{url.path}, but file does not exist." if url && !File.exist?(url.path)
+      config = self.class.deep_symbolize(Hocon.load(url.path, syntax: Hocon::ConfigSyntax::HOCON) || {})
+    elsif url_or_config_or_transport.is_a? Hash
+      config = url_or_config_or_transport
+    elsif transport_class?(name, url_or_config_or_transport)
+      @transport = url_or_config_or_transport
+    end
+
+    @transport ||= Puppet::ResourceApi::Transport.connect(name, config)
+    @schema = Puppet::ResourceApi::Transport.list[name]
+  end
+
+  def transport_class?(name, transport)
+    class_name = name.split('_').map { |e| e.capitalize }.join
+    expected = Puppet::Transport.const_get(class_name).to_s
+    expected == transport.class.to_s
+  end
+
+  def facts
+    context = Puppet::ResourceApi::PuppetContext.new(@schema)
+    # @transport.facts + custom_facts  # look into custom facts work by TP
+    @transport.facts(context)
+  end
+
+  def respond_to_missing?(name, _include_private)
+    (@transport.respond_to? name) || super
+  end
+
+  def method_missing(method_name, *args, &block)
+    if @transport.respond_to? method_name
+      @transport.send(method_name, *args, &block)
+    else
+      super
+    end
+  end
+
+  # From https://stackoverflow.com/a/11788082/4918
+  def self.deep_symbolize(obj)
+    return obj.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = deep_symbolize(v); } if obj.is_a? Hash
+    return obj.each_with_object([]) { |v, memo| memo << deep_symbolize(v); } if obj.is_a? Array
+    obj
+  end
+end

data/lib/puppet/resource_api/type_definition.rb

@@ -1,144 +1,187 @@
 # Provides accessor methods for the type being provided
-class Puppet::ResourceApi::TypeDefinition
-  attr_reader :definition
-
-  def initialize(definition)
-    @data_type_cache = {}
-    validate_schema(definition)
-  end
+module Puppet::ResourceApi
+  # pre-declare class
+  class BaseTypeDefinition; end
+
+  # RSAPI Resource Type
+  class TypeDefinition < BaseTypeDefinition
+    def initialize(definition)
+      super(definition, :attributes)
+    end
 
-  def name
-    @definition[:name]
-  end
+    def ensurable?
+      attributes.key?(:ensure)
+    end
 
-  def attributes
-    @definition[:attributes]
-  end
+    # rubocop complains when this is named has_feature?
+    def feature?(feature)
+      supported = (definition[:features] && definition[:features].include?(feature))
+      if supported
+        Puppet.debug("#{definition[:name]} supports `#{feature}`")
+      else
+        Puppet.debug("#{definition[:name]} does not support `#{feature}`")
+      end
+      supported
+    end
 
-  def ensurable?
-    @definition[:attributes].key?(:ensure)
-  end
+    def validate_schema(definition, attr_key)
+      super(definition, attr_key)
+      [:title, :provider, :alias, :audit, :before, :consume, :export, :loglevel, :noop, :notify, :require, :schedule, :stage, :subscribe, :tag].each do |name|
+        raise Puppet::DevError, 'must not define an attribute called `%{name}`' % { name: name.inspect } if definition[attr_key].key? name
+      end
+      if definition.key?(:title_patterns) && !definition[:title_patterns].is_a?(Array)
+        raise Puppet::DevError, '`:title_patterns` must be an array, not `%{other_type}`' % { other_type: definition[:title_patterns].class }
+      end
 
-  def namevars
-    @namevars ||= @definition[:attributes].select { |_name, options|
-      options.key?(:behaviour) && options[:behaviour] == :namevar
-    }.keys
-  end
+      Puppet::ResourceApi::DataTypeHandling.validate_ensure(definition)
 
-  # rubocop complains when this is named has_feature?
-  def feature?(feature)
-    supported = (definition[:features] && definition[:features].include?(feature))
-    if supported
-      Puppet.debug("#{definition[:name]} supports `#{feature}`")
-    else
-      Puppet.debug("#{definition[:name]} does not support `#{feature}`")
+      definition[:features] ||= []
+      supported_features = %w[supports_noop canonicalize remote_resource simple_get_filter].freeze
+      unknown_features = definition[:features] - supported_features
+      Puppet.warning("Unknown feature detected: #{unknown_features.inspect}") unless unknown_features.empty?
     end
-    supported
   end
 
-  def validate_schema(definition)
-    raise Puppet::DevError, 'Type definition must be a Hash, not `%{other_type}`' % { other_type: definition.class } unless definition.is_a?(Hash)
-    raise Puppet::DevError, 'Type definition must have a name' unless definition.key? :name
-    raise Puppet::DevError, 'Type definition must have `:attributes`' unless definition.key? :attributes
-    unless definition[:attributes].is_a?(Hash)
-      raise Puppet::DevError, '`%{name}.attributes` must be a hash, not `%{other_type}`' % {
-        name: definition[:name], other_type: definition[:attributes].class
-      }
-    end
-    [:title, :provider, :alias, :audit, :before, :consume, :export, :loglevel, :noop, :notify, :require, :schedule, :stage, :subscribe, :tag].each do |name|
-      raise Puppet::DevError, 'must not define an attribute called `%{name}`' % { name: name.inspect } if definition[:attributes].key? name
+  # RSAPI Transport schema
+  class TransportSchemaDef < BaseTypeDefinition
+    def initialize(definition)
+      super(definition, :connection_info)
     end
-    if definition.key?(:title_patterns) && !definition[:title_patterns].is_a?(Array)
-      raise Puppet::DevError, '`:title_patterns` must be an array, not `%{other_type}`' % { other_type: definition[:title_patterns].class }
+
+    def validate(resource)
+      # enforce mandatory attributes
+      missing_attrs = []
+
+      attributes.each do |name, _options|
+        type = @data_type_cache[attributes[name][:type]]
+
+        if resource[name].nil? && !(type.instance_of? Puppet::Pops::Types::POptionalType)
+          missing_attrs << name
+        end
+      end
+
+      error_msg = "The following mandatory attributes were not provided:\n    *  " + missing_attrs.join(", \n    *  ")
+      raise Puppet::ResourceError, error_msg if missing_attrs.any?
     end
+  end
 
-    Puppet::ResourceApi::DataTypeHandling.validate_ensure(definition)
+  # Base RSAPI schema Object
+  class BaseTypeDefinition
+    attr_reader :definition, :attributes
 
-    definition[:features] ||= []
-    supported_features = %w[supports_noop canonicalize remote_resource simple_get_filter].freeze
-    unknown_features = definition[:features] - supported_features
-    Puppet.warning("Unknown feature detected: #{unknown_features.inspect}") unless unknown_features.empty?
+    def initialize(definition, attr_key)
+      @data_type_cache = {}
+      validate_schema(definition, attr_key)
+      # store the validated definition
+      @definition = definition
+    end
 
-    definition[:attributes].each do |key, attr|
-      raise Puppet::DevError, "`#{definition[:name]}.#{key}` must be a Hash, not a #{attr.class}" unless attr.is_a? Hash
-      raise Puppet::DevError, "`#{definition[:name]}.#{key}` has no type" unless attr.key? :type
-      Puppet.warning("`#{definition[:name]}.#{key}` has no docs") unless attr.key? :desc
+    def name
+      definition[:name]
+    end
 
-      # validate the type by attempting to parse into a puppet type
-      @data_type_cache[definition[:attributes][key][:type]] ||=
-        Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
-          key,
-          definition[:attributes][key][:type],
-        )
+    def namevars
+      @namevars ||= attributes.select { |_name, options|
+        options.key?(:behaviour) && options[:behaviour] == :namevar
+      }.keys
+    end
 
-      # fixup any weird behavior  ;-)
-      next unless attr[:behavior]
-      if attr[:behaviour]
-        raise Puppet::DevError, "the '#{key}' attribute has both a `behavior` and a `behaviour`, only use one"
+    def validate_schema(definition, attr_key)
+      raise Puppet::DevError, '%{type_class} must be a Hash, not `%{other_type}`' % { type_class: self.class.name, other_type: definition.class } unless definition.is_a?(Hash)
+      @attributes = definition[attr_key]
+      raise Puppet::DevError, '%{type_class} must have a name' % { type_class: self.class.name } unless definition.key? :name
+      raise Puppet::DevError, '%{type_class} must have `%{attr_key}`' % { type_class: self.class.name, attrs: attr_key } unless definition.key? attr_key
+      unless attributes.is_a?(Hash)
+        raise Puppet::DevError, '`%{name}.%{attrs}` must be a hash, not `%{other_type}`' % {
+          name: definition[:name], attrs: attr_key, other_type: attributes.class
+        }
       end
-      attr[:behaviour] = attr[:behavior]
-      attr.delete(:behavior)
-    end
-    # store the validated definition
-    @definition = definition
-  end
 
-  # validates a resource hash against its type schema
-  def check_schema(resource)
-    namevars.each do |namevar|
-      if resource[namevar].nil?
-        raise Puppet::ResourceError, "`#{name}.get` did not return a value for the `#{namevar}` namevar attribute"
+      attributes.each do |key, attr|
+        raise Puppet::DevError, "`#{definition[:name]}.#{key}` must be a Hash, not a #{attr.class}" unless attr.is_a? Hash
+        raise Puppet::DevError, "`#{definition[:name]}.#{key}` has no type" unless attr.key? :type
+        Puppet.warning("`#{definition[:name]}.#{key}` has no docs") unless attr.key? :desc
+
+        # validate the type by attempting to parse into a puppet type
+        @data_type_cache[attributes[key][:type]] ||=
+          Puppet::ResourceApi::DataTypeHandling.parse_puppet_type(
+            key,
+            attributes[key][:type],
+          )
+
+        # fixup any weird behavior  ;-)
+        next unless attr[:behavior]
+        if attr[:behaviour]
+          raise Puppet::DevError, "the '#{key}' attribute has both a `behavior` and a `behaviour`, only use one"
+        end
+        attr[:behaviour] = attr[:behavior]
+        attr.delete(:behavior)
       end
     end
 
-    message = "Provider returned data that does not match the Type Schema for `#{name}[#{resource[namevars.first]}]`"
+    # validates a resource hash against its type schema
+    def check_schema(resource, message_prefix = nil)
+      namevars.each do |namevar|
+        if resource[namevar].nil?
+          raise Puppet::ResourceError, "`#{name}.get` did not return a value for the `#{namevar}` namevar attribute"
+        end
+      end
 
-    rejected_keys = check_schema_keys(resource) # removes bad keys
-    bad_values = check_schema_values(resource)
+      message_prefix = 'Provider returned data that does not match the Type Schema' if message_prefix.nil?
+      message = "#{message_prefix} for `#{name}[#{resource[namevars.first]}]`"
 
-    unless rejected_keys.empty?
-      message += "\n Unknown attribute:\n"
-      rejected_keys.each { |key, _value| message += "    * #{key}\n" }
-    end
-    unless bad_values.empty?
-      message += "\n Value type mismatch:\n"
-      bad_values.each { |key, value| message += "    * #{key}: #{value}\n" }
-    end
+      rejected_keys = check_schema_keys(resource)
+      bad_values = check_schema_values(resource)
 
-    return if rejected_keys.empty? && bad_values.empty?
+      unless rejected_keys.empty?
+        message += "\n Unknown attribute:\n"
+        rejected_keys.each { |key, _value| message += "    * #{key}\n" }
+      end
+      unless bad_values.empty?
+        message += "\n Value type mismatch:\n"
+        bad_values.each { |key, value| message += "    * #{key}: #{value}\n" }
+      end
+
+      return if rejected_keys.empty? && bad_values.empty?
 
-    if Puppet.settings[:strict] == :off
-      Puppet.debug(message)
-    elsif Puppet.settings[:strict] == :warning
-      Puppet::ResourceApi.warning_count += 1
-      Puppet.warning(message) if Puppet::ResourceApi.warning_count <= 100 # maximum number of schema warnings to display in a run
-    elsif Puppet.settings[:strict] == :error
-      raise Puppet::DevError, message
+      if Puppet.settings[:strict] == :off
+        Puppet.debug(message)
+      elsif Puppet.settings[:strict] == :warning
+        Puppet::ResourceApi.warning_count += 1
+        Puppet.warning(message) if Puppet::ResourceApi.warning_count <= 100 # maximum number of schema warnings to display in a run
+      elsif Puppet.settings[:strict] == :error
+        raise Puppet::DevError, message
+      end
     end
-  end
 
-  # Returns an array of keys that where not found in the type schema
-  # Modifies the resource passed in, leaving only valid attributes
-  def check_schema_keys(resource)
-    rejected = []
-    resource.reject! { |key| rejected << key if key != :title && attributes.key?(key) == false }
-    rejected
-  end
+    # Returns an array of keys that where not found in the type schema
+    # No longer modifies the resource passed in
+    def check_schema_keys(resource)
+      rejected = []
+      resource.reject { |key| rejected << key if key != :title && attributes.key?(key) == false }
+      rejected
+    end
 
-  # Returns a hash of keys and values that are not valid
-  # does not modify the resource passed in
-  def check_schema_values(resource)
-    bad_vals = {}
-    resource.each do |key, value|
-      next unless attributes[key]
-      type = @data_type_cache[attributes[key][:type]]
-      error_message = Puppet::ResourceApi::DataTypeHandling.try_validate(
-        type,
-        value,
-        '',
-      )
-      bad_vals[key] = value unless error_message.nil?
+    # Returns a hash of keys and values that are not valid
+    # does not modify the resource passed in
+    def check_schema_values(resource)
+      bad_vals = {}
+      resource.each do |key, value|
+        next unless attributes[key]
+        type = @data_type_cache[attributes[key][:type]]
+        is_sensitive = (attributes[key].key?(:sensitive) && (attributes[key][:sensitive] == true))
+        error_message = Puppet::ResourceApi::DataTypeHandling.try_validate(
+          type,
+          value,
+          '',
+        )
+        if is_sensitive
+          bad_vals[key] = '<< redacted value >> ' + error_message unless error_message.nil?
+        else
+          bad_vals[key] = value unless error_message.nil?
+        end
+      end
+      bad_vals
     end
-    bad_vals
   end
 end

data/lib/puppet/resource_api/version.rb

@@ -1,5 +1,5 @@
 module Puppet
   module ResourceApi
-    VERSION = '1.7.0'.freeze
+    VERSION = '1.8.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-resource_api
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - David Schmitt
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-24 00:00:00.000000000 Z
+date: 2019-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hocon
@@ -36,7 +36,6 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".rubocop_todo.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
@@ -61,6 +60,8 @@ files:
 - lib/puppet/resource_api/puppet_context.rb
 - lib/puppet/resource_api/read_only_parameter.rb
 - lib/puppet/resource_api/simple_provider.rb
+- lib/puppet/resource_api/transport.rb
+- lib/puppet/resource_api/transport/wrapper.rb
 - lib/puppet/resource_api/type_definition.rb
 - lib/puppet/resource_api/value_creator.rb
 - lib/puppet/resource_api/version.rb
@@ -87,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: This library provides a simple way to write new native resources for puppet.

data/.rubocop_todo.yml

@@ -1,17 +0,0 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2017-09-05 11:31:11 +0100 using RuboCop version 0.49.1.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 6
-Style/Documentation:
-  Exclude:
-    - 'spec/**/*'
-    - 'test/**/*'
-    - 'lib/puppet/resource_api.rb'
-    - 'lib/puppet/resource_api/base_context.rb'
-    - 'lib/puppet/resource_api/io_context.rb'
-    - 'lib/puppet/resource_api/puppet_context.rb'