WIP: Rework network_route provider with resource_api

.sync.yml

@@ -6,6 +6,8 @@ spec/spec_helper.rb:
   spec_overrides: "require 'spec_helper_methods'"
 Gemfile:
   optional:
+    ':development':
+      - gem: 'puppet-resource_api'
     ':test':
       - gem: 'ipaddress'
       - gem: 'rspec-its'

Gemfile

@@ -31,6 +31,7 @@ group :test do
   gem 'rack', '~> 1.0',                                             :require => false if RUBY_VERSION < '2.2.2'
   gem 'parallel_tests',                                             :require => false
   gem 'ipaddress',                                                  :require => false
+  gem 'net-ip',                                                     :require => false
   gem 'rspec-its',                                                  :require => false
 end
 
@@ -39,6 +40,7 @@ group :development do
   gem 'travis-lint',              :require => false
   gem 'guard-rake',               :require => false
   gem 'overcommit', '>= 0.39.1',  :require => false
+  gem 'puppet-resource_api',      :require => false
 end
 
 group :system_tests do

lib/puppet/provider/network_route/network_route.rb

@@ -0,0 +1,96 @@
+require 'net/ip'
+# require_relative '../../../puppet_x/voxpupuli/utils'
+require 'puppet/resource_api/simple_provider'
+
+# Implementation for the network_route type using the Resource API.
+class Puppet::Provider::NetworkRoute::NetworkRoute
+  # include PuppetX::FileMapper
+
+  def routes_list
+    routes = []
+    Net::IP.routes.each do |route|
+      routes.push(route.to_h)
+    end
+    routes
+  end
+
+  def get(_context)
+    routes_list.map do |route|
+      default = if route[:prefix] == 'default'
+                  true
+                else
+                  false
+                end
+
+      {
+        ensure: 'present',
+        prefix: route[:prefix],
+        default_route: default,
+        gateway: route[:via],
+        interface: route[:dev],
+        metric: route[:metric],
+        table: route[:table],
+        source: route[:src],
+        scope: route[:scope],
+        protocol: route[:proto],
+        mtu: route[:mtu]
+      }.compact!
+    end
+  end
+
+  def puppet_munge(should)
+    should.delete(:ensure)
+    if should[:default_route]
+      should[:prefix] = 'default'
+      should.delete(:default_route)
+    else
+      should[:prefix] = should.delete(:prefix)
+    end
+    should[:via] = should.delete(:gateway) if should[:gateway]
+    should[:dev] = should.delete(:interface) if should[:interface]
+    should[:metric] = should.delete(:metric)
+    should[:table] = should.delete(:table) if should[:table]
+    should[:src] = should.delete(:source) if should[:source]
+    should[:scope] = should.delete(:scope) if should[:scope]
+    should[:proto] = should.delete(:protocol)
+    should[:mtu] = should.delete(:mtu) if should[:mtu]
+    should
+  end
+
+  def set(context, changes)
+    changes.each do |name, change|
+      is = change.key?(:is) ? change[:is] : get_single(name)
+      should = change[:should]
+
+      is = { prefix: name, ensure: 'absent' } if is.nil?
+      should = { prefix: name, ensure: 'absent' } if should.nil?
+
+      if is[:ensure].to_s == 'absent' && should[:ensure].to_s == 'present'
+        create(context, name, should)
+      elsif is[:ensure] == should[:ensure] && is != should
+        update(context, name, should)
+      elsif is[:ensure].to_s == 'present' && should[:ensure].to_s == 'absent'
+        delete(context, name, should)
+      end
+    end
+  end
+
+  def create(context, name, should)
+    puppet_munge(should)
+    route = Net::IP::Route.new(should)
+    Net::IP.routes.add(route)
+  end
+
+  def update(context, name, should)
+    puppet_munge(should)
+    route = Net::IP::Route.new(should)
+    Net::IP.routes.flush(route.prefix)
+    Net::IP.routes.add(route)
+  end
+
+  def delete(context, name, should)
+    puppet_munge(should)
+    route = Net::IP::Route.new(should)
+    Net::IP.routes.flush(route.prefix)
+  end
+end

lib/puppet/type/network_route.rb

@@ -1,81 +1,58 @@
-require 'ipaddr'
-require_relative '../../puppet_x/voxpupuli/utils.rb'
-
-Puppet::Type.newtype(:network_route) do
-  @doc = 'Manage non-volatile route configuration information'
-
-  include PuppetX::Voxpupuli::Utils
-
-  ensurable
-
-  newparam(:name) do
-    isnamevar
-    desc 'The name of the network route'
-  end
-
-  newproperty(:network) do
-    isrequired
-    desc 'The target network address'
-    validate do |value|
-      unless value == 'default'
-        a = PuppetX::Voxpupuli::Utils.try { IPAddr.new(value) }
-        raise("Invalid value for network: #{value}") unless a
-      end
-    end
-  end
-
-  newproperty(:netmask) do
-    isrequired
-    desc 'The subnet mask to apply to the route'
-
-    validate do |value|
-      unless value.length <= 3 || PuppetX::Voxpupuli::Utils.try { IPAddr.new(value) }
-        raise("Invalid value for argument netmask: #{value}")
-      end
-    end
-
-    munge do |value|
-      # '255.255.255.255'.to_i  will return 255, so we try to convert it back:
-      if value.to_i.to_s == value
-        # what are the chances someone is using /16 for their IPv6 network?
-        addr = value.to_i <= 32 ? '255.255.255.255' : 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
-        IPAddr.new(addr).mask(value.strip.to_i).to_s
-      elsif PuppetX::Voxpupuli::Utils.try { IPAddr.new(value).ipv6? }
-        IPAddr.new('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff').mask(value).to_s
-      elsif PuppetX::Voxpupuli::Utils.try { IPAddr.new(value).ipv4? }
-        IPAddr.new('255.255.255.255').mask(value).to_s
-      else
-        raise("Invalid value for argument netmask: #{value}")
-      end
-    end
-  end
-
-  newproperty(:gateway) do
-    isrequired
-    desc 'The gateway to use for the route'
-
-    validate do |value|
-      begin
-        IPAddr.new(value)
-      rescue ArgumentError
-        raise("Invalid value for gateway: #{value}")
-      end
-    end
-  end
-
-  newproperty(:interface) do
-    isrequired
-    desc 'The interface to use for the route'
-  end
-
-  # `:options` provides an arbitrary passthrough for provider properties, so
-  # that provider specific behavior doesn't clutter up the main type but still
-  # allows for more powerful actions to be taken.
-  newproperty(:options, required_features: :provider_options) do
-    desc 'Provider specific options to be passed to the provider'
-
-    validate do |value|
-      raise ArgumentError, "#{self.class} requires a string for the options property" unless value.is_a?(String)
-    end
-  end
-end
+require 'puppet/resource_api'
+
+Puppet::ResourceApi.register_type(
+  name: 'network_route',
+  docs: <<-EOS,
+      Manage non-volatile route configuration information.
+    EOS
+  attributes:   {
+    ensure:      {
+      type:    'Enum[present, absent]',
+      desc:    'Whether the network route should be present or absent on the target system.',
+      default: 'present',
+    },
+    prefix:        {
+      type:      'String',
+      desc:      'The destination prefix/network of the route.',
+      behaviour: :namevar,
+    },
+    default_route: {
+      type:      'Optional[Boolean]',
+      desc:      'Whether the route is default or not.',
+    },
+    gateway:     {
+      type:      'Optional[String]',
+      desc:      'The gateway to use for the route.',
+    },
+    interface:   {
+      type:      'Optional[String]',
+      desc:      'The interface to use for the route.',
+    },
+    metric: {
+      type:      'String',
+      desc:      'preference value of the route. NUMBER is an arbitrary 32bit number.',
+      default:   '100',
+    },
+    table: {
+      type:      'Optional[String]',
+      desc:      'table to add this route.',
+    },
+    source: {
+      type:      'Optional[String]',
+      desc:      'the source address to prefer using when sending to the destinations covered by route prefix.',
+    },
+    scope: {
+      type:      'Optional[Enum["global", "nowhere", "host", "link", "site"]]',
+      desc:      'scope of the destinations covered by the route prefix.',
+    },
+    protocol: {
+      type:      'String',
+      desc:      'routing protocol identifier of this route.',
+      default:   'static',
+    },
+    mtu: {
+      type:      'Optional[String]',
+      desc:      'the MTU along the path to destination.',
+    },
+  },
+)

lib/puppet/type/network_route_old.rb

@@ -0,0 +1,81 @@
+require 'ipaddr'
+require_relative '../../puppet_x/voxpupuli/utils.rb'
+
+Puppet::Type.newtype(:network_route) do
+  @doc = 'Manage non-volatile route configuration information'
+
+  include PuppetX::Voxpupuli::Utils
+
+  ensurable
+
+  newparam(:name) do
+    isnamevar
+    desc 'The name of the network route'
+  end
+
+  newproperty(:network) do
+    isrequired
+    desc 'The target network address'
+    validate do |value|
+      unless value == 'default'
+        a = PuppetX::Voxpupuli::Utils.try { IPAddr.new(value) }
+        raise("Invalid value for network: #{value}") unless a
+      end
+    end
+  end
+
+  newproperty(:netmask) do
+    isrequired
+    desc 'The subnet mask to apply to the route'
+
+    validate do |value|
+      unless value.length <= 3 || PuppetX::Voxpupuli::Utils.try { IPAddr.new(value) }
+        raise("Invalid value for argument netmask: #{value}")
+      end
+    end
+
+    munge do |value|
+      # '255.255.255.255'.to_i  will return 255, so we try to convert it back:
+      if value.to_i.to_s == value
+        # what are the chances someone is using /16 for their IPv6 network?
+        addr = value.to_i <= 32 ? '255.255.255.255' : 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+        IPAddr.new(addr).mask(value.strip.to_i).to_s
+      elsif PuppetX::Voxpupuli::Utils.try { IPAddr.new(value).ipv6? }
+        IPAddr.new('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff').mask(value).to_s
+      elsif PuppetX::Voxpupuli::Utils.try { IPAddr.new(value).ipv4? }
+        IPAddr.new('255.255.255.255').mask(value).to_s
+      else
+        raise("Invalid value for argument netmask: #{value}")
+      end
+    end
+  end
+
+  newproperty(:gateway) do
+    isrequired
+    desc 'The gateway to use for the route'
+
+    validate do |value|
+      begin
+        IPAddr.new(value)
+      rescue ArgumentError
+        raise("Invalid value for gateway: #{value}")
+      end
+    end
+  end
+
+  newproperty(:interface) do
+    isrequired
+    desc 'The interface to use for the route'
+  end
+
+  # `:options` provides an arbitrary passthrough for provider properties, so
+  # that provider specific behavior doesn't clutter up the main type but still
+  # allows for more powerful actions to be taken.
+  newproperty(:options, required_features: :provider_options) do
+    desc 'Provider specific options to be passed to the provider'
+
+    validate do |value|
+      raise ArgumentError, "#{self.class} requires a string for the options property" unless value.is_a?(String)
+    end
+  end
+end

spec/unit/puppet/provider/network_route/network_route_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+ensure_module_defined('Puppet::Provider::NetworkRoute')
+require 'puppet/provider/network_route/network_route'
+
+RSpec.describe Puppet::Provider::NetworkRoute::NetworkRoute do
+  subject(:provider) { described_class.new }
+
+  let(:context) { instance_double('Puppet::ResourceApi::BaseContext', 'context') }
+
+  describe '#get' do
+    it 'processes resources' do
+      expect(provider.get(context)).to eq [
+        {
+          name: 'foo',
+          ensure: 'present',
+        },
+        {
+          name: 'bar',
+          ensure: 'present',
+        },
+      ]
+    end
+  end
+
+  describe 'create(context, name, should)' do
+    it 'creates the resource' do
+      expect(context).to receive(:notice).with(%r{\ACreating 'a'})
+
+      provider.create(context, 'a', name: 'a', ensure: 'present')
+    end
+  end
+
+  describe 'update(context, name, should)' do
+    it 'updates the resource' do
+      expect(context).to receive(:notice).with(%r{\AUpdating 'foo'})
+
+      provider.update(context, 'foo', name: 'foo', ensure: 'present')
+    end
+  end
+
+  describe 'delete(context, name, should)' do
+    it 'deletes the resource' do
+      expect(context).to receive(:notice).with(%r{\ADeleting 'foo'})
+
+      provider.delete(context, 'foo')
+    end
+  end
+end