foreman_netbox 1.1.1 → 2.0.0

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/create.rb

@@ -17,14 +17,14 @@ module ForemanNetbox
                          .select { |i| i[:name] }
                          .reject { |i| interfaces.map(&:name).include?(i[:name]) }
                          .map do |new_interface|
-                           ForemanNetbox::API.client::Virtualization::Interface.new(
-                             new_interface.except(:type)
-                                          .merge(
-                                            virtual_machine: virtual_machine.id,
-                                            tags: default_tag_ids
-                                          )
-                           ).save
-                         end
+              ForemanNetbox::Api.client::Virtualization::Interface.new(
+                new_interface.except(:type)
+                .merge(
+                  virtual_machine: virtual_machine.id,
+                  tags: default_tag_ids
+                )
+              ).save
+            end
           rescue NetboxClientRuby::LocalError, NetboxClientRuby::ClientError, NetboxClientRuby::RemoteError => e
             ::Foreman::Logging.logger('foreman_netbox/import').error("#{self.class} error #{e}: #{e.backtrace}")
             context.fail!(error: "#{self.class}: #{e}")

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/find.rb

@@ -8,7 +8,7 @@ module ForemanNetbox
           include ::Interactor
 
           def call
-            context.interfaces = ForemanNetbox::API.client.virtualization.interfaces.filter(params)
+            context.interfaces = ForemanNetbox::Api.client.virtualization.interfaces.filter(params)
           rescue NetboxClientRuby::LocalError, NetboxClientRuby::ClientError, NetboxClientRuby::RemoteError => e
             ::Foreman::Logging.logger('foreman_netbox/import').error("#{self.class} error #{e}: #{e.backtrace}")
             context.fail!(error: "#{self.class}: #{e}")
@@ -20,7 +20,7 @@ module ForemanNetbox
 
           def params
             {
-              virtual_machine_id: virtual_machine.id
+              virtual_machine_id: virtual_machine.id,
             }
           end
         end

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/organizer.rb

@@ -12,10 +12,10 @@ module ForemanNetbox
           end
 
           organize SyncInterfaces::Find,
-                   SyncInterfaces::Delete,
-                   SyncInterfaces::Create,
-                   SyncInterfaces::SyncIpAddresses::Organizer,
-                   SyncInterfaces::Update
+            SyncInterfaces::Delete,
+            SyncInterfaces::Create,
+            SyncInterfaces::SyncIpAddresses::Organizer,
+            SyncInterfaces::Update
         end
       end
     end

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/sync_ip_addresses/create.rb

@@ -14,14 +14,14 @@ module ForemanNetbox
                 interface_id = interfaces_map.fetch(ip_address.dig(:interface, :name), nil)
 
                 next unless interface_id
-                next unless ForemanNetbox::API.client
+                next unless ForemanNetbox::Api.client
                                               .ipam
                                               .ip_addresses
                                               .filter(vminterface_id: interface_id, address: ip_address[:address])
                                               .total
                                               .zero?
 
-                ForemanNetbox::API.client::IPAM::IpAddress.new(
+                ForemanNetbox::Api.client::IPAM::IpAddress.new(
                   ip_address.slice(:address)
                             .merge(
                               assigned_object_type: 'virtualization.vminterface', assigned_object_id: interface_id,

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/sync_ip_addresses/delete.rb

@@ -21,8 +21,9 @@ module ForemanNetbox
               ip_addresses_netbox_params = netbox_params.fetch(:ip_addresses, [])
 
               context.interfaces.each do |netbox_interface|
-                host_interface_ips = ip_addresses_netbox_params.select { |ip| ip.dig(:interface, :name) == netbox_interface.name }
-                                                               .map { |ip| ip.fetch(:address) }
+                host_interface_ips = ip_addresses_netbox_params.select do |ip|
+                  ip.dig(:interface, :name) == netbox_interface.name
+                end.map { |ip| ip.fetch(:address) }
 
                 context.ip_addresses
                        .select { |ip| ip['assigned_object_type'] == 'virtualization.vminterface' && ip['assigned_object_id'] == netbox_interface.id }
@@ -30,7 +31,6 @@ module ForemanNetbox
                        .each(&:delete)
               end
             end
-
             delegate :netbox_params, to: :context
           end
         end

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/sync_ip_addresses/find.rb

@@ -9,7 +9,7 @@ module ForemanNetbox
             include ::Interactor
 
             def call
-              context.ip_addresses = ForemanNetbox::API.client.ipam.ip_addresses.filter(params)
+              context.ip_addresses = ForemanNetbox::Api.client.ipam.ip_addresses.filter(params)
             rescue NetboxClientRuby::LocalError, NetboxClientRuby::ClientError, NetboxClientRuby::RemoteError => e
               ::Foreman::Logging.logger('foreman_netbox/import').error("#{self.class} error #{e}: #{e.backtrace}")
               context.fail!(error: "#{self.class}: #{e}")
@@ -17,7 +17,7 @@ module ForemanNetbox
 
             def params
               {
-                virtual_machine_id: context.virtual_machine.id
+                virtual_machine_id: context.virtual_machine.id,
               }
             end
           end

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/sync_ip_addresses/organizer.rb

@@ -13,9 +13,9 @@ module ForemanNetbox
             end
 
             organize SyncIpAddresses::Find,
-                     SyncIpAddresses::Delete,
-                     SyncIpAddresses::Update,
-                     SyncIpAddresses::Create
+              SyncIpAddresses::Delete,
+              SyncIpAddresses::Update,
+              SyncIpAddresses::Create
           end
         end
       end

data/app/lib/foreman_netbox/api.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
 module ForemanNetbox
-  class API
+  class Api
     def self.client
       NetboxClientRuby.configure do |config|
-        config.netbox.api_base_url = "#{Setting['netbox_url']}/api"
+        config.netbox.api_base_url = netbox_api_url
         config.netbox.auth.token = Setting['netbox_api_token']
       end
     end
+
+    def self.netbox_api_url
+      return Setting['netbox_api_url'] if URI.parse(Setting['netbox_api_url']).is_a?(URI::HTTP)
+
+      api_url = "#{Setting['netbox_url']}/api"
+      return api_url if URI.parse(api_url).is_a?(URI::HTTP)
+
+      raise Foreman::Exception, 'Invalid Netbox API URL, please check the netbox_url and netbox_api_url settings'
+    end
   end
 end

data/app/models/orchestration/netbox.rb

@@ -23,8 +23,7 @@ module Orchestration
       ::Foreman::Logging.logger('foreman_netbox/import')
                         .info("Queued import of #{name} to Netbox. Changes that will be sent: #{netbox_params_diff}")
 
-      post_queue.create(name: _('Push host %s to Netbox') % self, priority: 100,
-                        action: [self, :set_netbox])
+      post_queue.create(name: _('Push host %s to Netbox') % self, priority: 100, action: [self, :set_netbox])
     end
 
     def queue_netbox_destroy
@@ -33,8 +32,7 @@ module Orchestration
       ::Foreman::Logging.logger('foreman_netbox/import')
                         .info("Queued delete of #{name} from Netbox.")
 
-      queue.create(name: _('Delete host %s from Netbox') % self, priority: 60,
-                   action: [self, :del_netbox])
+      queue.create(name: _('Delete host %s from Netbox') % self, priority: 60, action: [self, :del_netbox])
     end
 
     def set_netbox

data/app/services/foreman_netbox/cached_netbox_parameters.rb

@@ -25,7 +25,7 @@ module ForemanNetbox
     attr_accessor :result
 
     def read_interfaces
-      return unless data.keys.include?(:interfaces)
+      return unless data.key?(:interfaces)
 
       result[:interfaces] = data.fetch(:interfaces, {}).fetch(:results, []).map do |interface|
         interface.slice(:name, :mac_address)
@@ -35,7 +35,7 @@ module ForemanNetbox
     end
 
     def read_ip_addresses
-      return unless data.keys.include?(:ip_addresses)
+      return unless data.key?(:ip_addresses)
 
       result[:ip_addresses] = data.fetch(:ip_addresses, {}).fetch(:results, []).map do |ip_address|
         ip_address.slice(:address)
@@ -44,31 +44,31 @@ module ForemanNetbox
     end
 
     def read_virtual_machine
-      return unless data.keys.include?(:virtual_machine)
+      return unless data.key?(:virtual_machine)
 
       result[:virtual_machine] = data.fetch(:virtual_machine, {}).slice(:name, :vcpus, :memory, :disk)
     end
 
     def read_tenant
-      return unless data.keys.include?(:tenant)
+      return unless data.key?(:tenant)
 
       result[:tenant] = data.fetch(:tenant, {}).slice(:name, :slug)
     end
 
     def read_cluster
-      return unless data.keys.include?(:cluster)
+      return unless data.key?(:cluster)
 
       result[:cluster] = data.fetch(:cluster, {}).slice(:name)
     end
 
     def read_cluster_type
-      return unless data.keys.include?(:cluster_type)
+      return unless data.key?(:cluster_type)
 
       result[:cluster_type] = data.fetch(:cluster_type, {}).slice(:name, :slug)
     end
 
     def read_device
-      return unless data.keys.include?(:device)
+      return unless data.key?(:device)
 
       result[:device] = data.fetch(:device, {})
                             .slice(:name, :serial)
@@ -77,25 +77,25 @@ module ForemanNetbox
     end
 
     def read_device_role
-      return unless data.keys.include?(:device_role)
+      return unless data.key?(:device_role)
 
       result[:device_role] = data.fetch(:device_role, {}).slice(:name, :color, :slug)
     end
 
     def read_device_type
-      return unless data.keys.include?(:device_type)
+      return unless data.key?(:device_type)
 
       result[:device_type] = data.fetch(:device_type, {}).slice(:model, :slug)
     end
 
     def read_manufacturer
-      return unless data.keys.include?(:manufacturer)
+      return unless data.key?(:manufacturer)
 
       result[:manufacturer] = data.fetch(:manufacturer, {}).slice(:name, :slug)
     end
 
     def read_site
-      return unless data.keys.include?(:site)
+      return unless data.key?(:site)
 
       result[:site] = data.fetch(:site, {}).slice(:name, :slug)
     end

data/app/services/foreman_netbox/netbox_parameters.rb

@@ -6,15 +6,15 @@ module ForemanNetbox
     UNKNOWN = 'Unknown'
     DEFAULT_INTERFACE_TYPE = 'virtual'
     CLUSTER_TYPES = {
-      :'Foreman::Model::Vmware' => {
+      'Foreman::Model::Vmware': {
         name: 'VMware ESXi',
-        slug: 'vmware-esxi'
-      }
+        slug: 'vmware-esxi',
+      },
     }.freeze
     DEVICE_ROLE = {
       name: 'SERVER',
       color: '9e9e9e',
-      slug: 'server'
+      slug: 'server',
     }.freeze
 
     def self.call(host)
@@ -46,7 +46,7 @@ module ForemanNetbox
           vcpus: compute_object&.cpus,
           memory: compute_object&.memory_mb,
           disk: compute_object&.volumes&.map(&:size_gb)&.reduce(&:+),
-          cluster: compute_object&.cluster
+          cluster: compute_object&.cluster,
         }.compact
       end
     end
@@ -55,8 +55,8 @@ module ForemanNetbox
       {
         tenant: {
           name: host.owner&.netbox_tenant_name,
-          slug: host.owner&.netbox_tenant_slug
-        }
+          slug: host.owner&.netbox_tenant_slug,
+        },
       }
     end
 
@@ -64,14 +64,14 @@ module ForemanNetbox
       {
         device: {
           name: host.name,
-          serial: host.facts.deep_symbolize_keys[:serialnumber]
-        }
+          serial: host.facts.deep_symbolize_keys[:serialnumber],
+        },
       }
     end
 
     def device_role
       {
-        device_role: DEVICE_ROLE
+        device_role: DEVICE_ROLE,
       }
     end
 
@@ -81,8 +81,8 @@ module ForemanNetbox
       {
         device_type: {
           model: model,
-          slug: model.parameterize
-        }
+          slug: model.parameterize,
+        },
       }
     end
 
@@ -92,8 +92,8 @@ module ForemanNetbox
       {
         manufacturer: {
           name: name,
-          slug: cached_netbox_params.dig(:manufacturer, :slug) || name.parameterize
-        }
+          slug: cached_netbox_params.dig(:manufacturer, :slug) || name.parameterize,
+        },
       }
     end
 
@@ -101,8 +101,8 @@ module ForemanNetbox
       {
         site: {
           name: host.location&.netbox_site_name,
-          slug: host.location&.netbox_site_slug
-        }
+          slug: host.location&.netbox_site_slug,
+        },
       }
     end
 
@@ -116,20 +116,20 @@ module ForemanNetbox
             name: identifier || (mac_address && "Interface #{mac_address}"),
             mac_address: mac_address,
             type: {
-              value: DEFAULT_INTERFACE_TYPE
-            }
+              value: DEFAULT_INTERFACE_TYPE,
+            },
           }
-        end
+        end,
       }
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
     def ip_addresses
       {
         ip_addresses: host.interfaces.map do |interface|
           [
             interface.ip && interface.subnet && "#{interface.ip}/#{interface.subnet.cidr}",
-            interface.ip6 && interface.subnet6 && "#{interface.ip6}/#{interface.subnet6.cidr}"
+            interface.ip6 && interface.subnet6 && "#{interface.ip6}/#{interface.subnet6.cidr}",
           ].compact.map do |ip_address|
             identifier = interface.identifier.present? && interface.identifier
             mac_address = interface.mac&.upcase
@@ -137,14 +137,14 @@ module ForemanNetbox
             {
               address: ip_address,
               interface: {
-                name: identifier || (mac_address && "Interface #{mac_address}")
-              }
+                name: identifier || (mac_address && "Interface #{mac_address}"),
+              },
             }
           end
-        end.flatten
+        end.flatten,
       }
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def virtual_machine
       {
@@ -152,15 +152,15 @@ module ForemanNetbox
           :vcpus, :memory, :disk
         ).merge(
           name: host.name
-        )
+        ),
       }
     end
 
     def cluster
       {
         cluster: {
-          name: netbox_compute_attributes[:cluster]
-        }.compact
+          name: netbox_compute_attributes[:cluster],
+        }.compact,
       }
     end
 
@@ -168,7 +168,7 @@ module ForemanNetbox
       type = host.compute_resource&.type&.to_sym
 
       {
-        cluster_type: CLUSTER_TYPES.fetch(type, nil)
+        cluster_type: CLUSTER_TYPES.fetch(type, nil),
       }
     end
   end

data/app/services/foreman_netbox/netbox_parameters_comparator.rb

@@ -32,22 +32,27 @@ module ForemanNetbox
     def keys_diff
       result = {}
 
-      result[:added] = added_keys.each_with_object({}) { |key, memo| memo[key] = new_hash[key] } if added_keys.any?
-      result[:removed] = removed_keys.each_with_object({}) { |key, memo| memo[key] = old_hash[key] } if removed_keys.any?
+      result[:added] = added_keys.index_with { |key| new_hash[key] } if added_keys.any?
+      if removed_keys.any?
+        result[:removed] = removed_keys.index_with do |key|
+          old_hash[key]
+        end
+      end
 
       result
     end
 
     def diff_old
       old_hash.except(*removed_keys).each_with_object({}) do |(key, old_value), memo|
-        if old_value.is_a?(Hash)
+        case old_value
+        when Hash
           new_value = new_hash.fetch(key, {})
           diff = ForemanNetbox::NetboxParametersComparator.call(old_value, new_value)
 
           next unless diff.keys.any?
 
           memo[key] = diff
-        elsif old_value.is_a?(Array)
+        when Array
           next if new_hash[key]
 
           memo[key] = { added: [], removed: old_value }
@@ -61,10 +66,11 @@ module ForemanNetbox
       end.compact
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
     def diff_new
       new_hash.except(*added_keys).each_with_object({}) do |(key, new_value), memo|
-        if new_value.is_a?(Hash)
+        case new_value
+        when Hash
           old_value = old_hash.fetch(key, {})
 
           next if old_value == new_value
@@ -74,7 +80,7 @@ module ForemanNetbox
           next unless diff.keys.any?
 
           memo[key] = diff
-        elsif new_value.is_a?(Array)
+        when Array
           old_value = old_hash.fetch(key, [])
           added = new_value.reject { |item| old_value.find { |x| x == item } }
           removed = old_value.reject { |item| new_value.find { |x| x == item } }
@@ -91,6 +97,6 @@ module ForemanNetbox
         end
       end.compact
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
   end
 end

data/db/migrate/20230303095650_fix_netbox_settings_category_to_dsl.rb

@@ -2,8 +2,6 @@
 
 class FixNetboxSettingsCategoryToDsl < ActiveRecord::Migration[6.0]
   def up
-    # rubocop:disable Rails/SkipsModelValidations
     Setting.where(category: 'Setting::Netbox').update_all(category: 'Setting') if column_exists?(:settings, :category)
-    # rubocop:enable Rails/SkipsModelValidations
   end
 end

data/lib/foreman_netbox/engine.rb

@@ -8,8 +8,6 @@ module ForemanNetbox
   class Engine < ::Rails::Engine
     engine_name 'foreman_netbox'
 
-    config.autoload_paths += Dir["#{config.root}/app/interactors"]
-
     # Add any db migrations
     initializer 'foreman_netbox.load_app_instance_data' do |app|
       ForemanNetbox::Engine.paths['db/migrate'].existent.each do |path|
@@ -17,51 +15,60 @@ module ForemanNetbox
       end
     end
 
-    initializer 'foreman_netbox.register_plugin', :before => :finisher_hook do |_app|
-      Foreman::Plugin.register :foreman_netbox do
-        requires_foreman '>= 3.1'
+    # rubocop:disable Metrics/BlockLength
+    initializer 'foreman_netbox.register_plugin', before: :finisher_hook do |app|
+      app.reloader.to_prepare do
+        Foreman::Plugin.register :foreman_netbox do
+          requires_foreman '>= 3.13'
 
-        # Netbox Facet
-        register_facet(ForemanNetbox::NetboxFacet, :netbox_facet) do
-          set_dependent_action :destroy
-        end
+          # Netbox Facet
+          register_facet(ForemanNetbox::NetboxFacet, :netbox_facet) do
+            set_dependent_action :destroy
+          end
 
-        # extend host show page
-        extend_page('hosts/show') do |context|
-          context.add_pagelet :main_tabs,
-                              name: N_('Netbox'),
-                              partial: 'hosts/netbox_tab',
-                              onlyif: proc { |host| host.netbox_facet.synchronized_at }
-        end
+          # extend host show page
+          extend_page('hosts/show') do |context|
+            context.add_pagelet :main_tabs,
+              name: N_('Netbox'),
+              partial: 'hosts/netbox_tab',
+              onlyif: proc { |host| host.netbox_facet.synchronized_at }
+          end
 
-        settings do
-          category(:netbox, N_('Netbox')) do
-            setting 'netbox_url',
-                    type: :string,
-                    default: '-',
-                    full_name: N_('Netbox URL'),
-                    description: N_('URL where Netbox is reachable')
-            setting 'netbox_api_token',
-                    type: :string,
-                    default: '-',
-                    full_name: N_('Netbox API token'),
-                    description: N_('API token to Netbox')
-            setting 'netbox_orchestration_enabled',
-                    type: :boolean,
-                    default: false,
-                    full_name: N_('Netbox Orchestration'),
-                    description: N_('Enable Netbox Orchestration')
-            setting 'netbox_skip_site_update',
-                    type: :boolean,
-                    default: false,
-                    full_name: N_('Skip Site Update'),
-                    description: N_('Skip updating Site attribute for Devices')
+          settings do
+            category(:netbox, N_('Netbox')) do
+              setting 'netbox_url',
+                type: :string,
+                default: '-',
+                full_name: N_('Netbox UI URL'),
+                description: N_('URL where Netbox UI is reachable')
+              setting 'netbox_api_url',
+                type: :string,
+                default: '-',
+                full_name: N_('Netbox API URL'),
+                description: N_('URL where Netbox API is reachable, in case it is different than Netbox UI')
+              setting 'netbox_api_token',
+                type: :string,
+                default: '-',
+                full_name: N_('Netbox API token'),
+                description: N_('API token to Netbox')
+              setting 'netbox_orchestration_enabled',
+                type: :boolean,
+                default: false,
+                full_name: N_('Netbox Orchestration'),
+                description: N_('Enable Netbox Orchestration')
+              setting 'netbox_skip_site_update',
+                type: :boolean,
+                default: false,
+                full_name: N_('Skip Site Update'),
+                description: N_('Skip updating Site attribute for Devices')
+            end
           end
-        end
 
-        logger :import, enabled: true
+          logger :import, enabled: true
+        end
       end
     end
+    # rubocop:enable Metrics/BlockLength
 
     config.to_prepare do
       ::Host::Managed.include(ForemanNetbox::HostExtensions)

data/lib/foreman_netbox/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanNetbox
-  VERSION = '1.1.1'
+  VERSION = '2.0.0'
 end

data/lib/tasks/foreman_netbox_tasks.rake

@@ -2,31 +2,6 @@
 
 require 'rake/testtask'
 
-namespace :foreman_netbox do
-  namespace :sync do
-    desc 'Example Task'
-    task full: :environment do
-      User.as_anonymous_admin do
-        Host::Managed.where(managed: true).each do |host|
-          unless host.netbox_facet.netbox_params_diff.empty?
-            puts "Nothing to push for #{host.name}"
-            next
-          end
-
-          puts "Pushing #{host.name} to Netbox"
-          result = host.push_to_netbox
-
-          if result.success?
-            puts "#{host.name} pushed"
-          else
-            puts "Failed to push #{host.name}: #{result.error}"
-          end
-        end
-      end
-    end
-  end
-end
-
 # Tests
 namespace :test do
   desc 'Test ForemanNetbox'
@@ -39,29 +14,4 @@ namespace :test do
   end
 end
 
-namespace :foreman_netbox do
-  task rubocop: :environment do
-    begin
-      require 'rubocop/rake_task'
-      RuboCop::RakeTask.new(:rubocop_foreman_netbox) do |task|
-        task.patterns = ["#{ForemanNetbox::Engine.root}/app/**/*.rb",
-                         "#{ForemanNetbox::Engine.root}/lib/**/*.rb",
-                         "#{ForemanNetbox::Engine.root}/test/**/*.rb"]
-      end
-    rescue StandardError
-      puts 'Rubocop not loaded.'
-    end
-
-    Rake::Task['rubocop_foreman_netbox'].invoke
-  end
-end
-
 Rake::Task[:test].enhance ['test:foreman_netbox']
-
-load 'tasks/jenkins.rake'
-
-# rubocop:disable Style/IfUnlessModifier
-if Rake::Task.task_defined?(:'jenkins:unit')
-  Rake::Task['jenkins:unit'].enhance ['test:foreman_netbox', 'foreman_netbox:rubocop']
-end
-# rubocop:enable Style/IfUnlessModifier