foreman_netbox 1.0.2

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        class Organizer
+          include ::Interactor::Organizer
+
+          after do
+            context.raw_data[:interfaces] = context.interfaces.reload.raw_data!
+          end
+
+          organize SyncInterfaces::Find,
+                   SyncInterfaces::Delete,
+                   SyncInterfaces::Create,
+                   SyncInterfaces::SyncIpAddresses::Organizer,
+                   SyncInterfaces::Update
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        module SyncIpAddresses
+          class Create
+            include ::Interactor
+
+            def call
+              netbox_params.fetch(:ip_addresses, []).map do |ip_address|
+                interface_id = interfaces_map.fetch(ip_address.dig(:interface, :name), nil)
+
+                next unless interface_id
+                next unless ForemanNetbox::API.client
+                                              .ipam
+                                              .ip_addresses
+                                              .filter(interface_id: interface_id, address: ip_address[:address])
+                                              .total
+                                              .zero?
+
+                ForemanNetbox::API.client::IPAM::IpAddress.new(
+                  ip_address.slice(:address, :tags).merge(interface: interface_id)
+                ).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}")
+            end
+
+            private
+
+            delegate :interfaces, :netbox_params, to: :context
+
+            def interfaces_map
+              interfaces.each_with_object({}) do |int, memo|
+                memo[int.name] = int.id
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        module SyncIpAddresses
+          class Delete
+            include ::Interactor
+
+            before do
+              context.interfaces.reload
+            end
+
+            def call
+              if context.interfaces.total.zero?
+                context.ip_addresses.each(&:delete)
+                return
+              end
+
+              ip_addresses_netbox_params = netbox_params.fetch(:ip_addresses, [])
+
+              context.interfaces.each do |netbox_interface|
+                host_interface_ips = ip_addresses_netbox_params.select { |i| i.dig(:interface, :name) == netbox_interface.name }
+                                                               .map { |i| i.fetch(:address) }
+
+                context.ip_addresses
+                       .select { |ip| ip['interface']['id'] == netbox_interface.id }
+                       .reject { |ip| host_interface_ips.include?(ip['address']) }
+                       .each(&:delete)
+              end
+            end
+
+            delegate :netbox_params, to: :context
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        module SyncIpAddresses
+          class Find
+            include ::Interactor
+
+            def call
+              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}")
+            end
+
+            private
+
+            delegate :device, to: :context
+
+            def params
+              {
+                device_id: device.id
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        module SyncIpAddresses
+          class Organizer
+            include ::Interactor::Organizer
+
+            after do
+              context.raw_data[:ip_addresses] = context.ip_addresses.reload.raw_data!
+            end
+
+            organize SyncIpAddresses::Find,
+                     SyncIpAddresses::Delete,
+                     SyncIpAddresses::Update,
+                     SyncIpAddresses::Create
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_interfaces/sync_ip_addresses/update.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        module SyncIpAddresses
+          class Update
+            include ::Interactor
+
+            def call
+              context.ip_addresses.each do |ip_address|
+                new_tags = tags_map.fetch(ip_address[:address], []) - ip_address.tags
+
+                ip_address.tags = (ip_address.tags | new_tags) if new_tags.any?
+
+                ip_address.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}")
+            end
+
+            private
+
+            delegate :netbox_params, to: :context
+
+            def tags_map
+              netbox_params.fetch(:ip_addresses, [])
+                           .each_with_object({}) do |item, memo|
+                             memo[item[:address]] = item.fetch(:tags, [])
+                           end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_interfaces/update.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncInterfaces
+        class Update
+          include ::Interactor
+
+          def call
+            context.interfaces.each { |netbox_interface| update(netbox_interface) }
+          end
+
+          private
+
+          delegate :netbox_params, to: :context
+
+          def update(netbox_interface)
+            new_params = netbox_params.fetch(:interfaces, [])
+                                      .find { |i| i[:name] == netbox_interface.name }
+
+            return unless new_params
+
+            netbox_interface.mac_address = new_params[:mac_address] if netbox_interface.mac_address != new_params[:mac_address]
+
+            new_tags = new_params.fetch(:tags, []) - netbox_interface.tags
+            netbox_interface.tags = (netbox_interface.tags | new_tags) if new_tags.any?
+
+            netbox_interface.save
+          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}")
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_site/create.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncSite
+        class Create
+          include ::Interactor
+
+          around do |interactor|
+            interactor.call unless context.site
+          end
+
+          def call
+            context.site = ForemanNetbox::API.client::DCIM::Site.new(params).save
+          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}")
+          end
+
+          private
+
+          delegate :netbox_params, to: :context
+
+          def params
+            netbox_params.fetch(:site).compact
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_site/find.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncSite
+        class Find
+          include ::Interactor
+
+          def call
+            context.site = ForemanNetbox::API.client.dcim.sites.find_by(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}")
+          end
+
+          private
+
+          delegate :netbox_params, to: :context
+
+          def params
+            netbox_params.fetch(:site).slice(:slug)
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_site/organizer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncSite
+        class Organizer
+          include ::Interactor::Organizer
+
+          around do |interactor|
+            interactor.call if context.host.location
+          end
+
+          after do
+            context.raw_data[:site] = context.site.raw_data!
+          end
+
+          organize SyncSite::Find,
+                   SyncSite::Update,
+                   SyncSite::Create
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/sync_site/update.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      module SyncSite
+        class Update
+          include ::Interactor
+
+          around do |interactor|
+            interactor.call if context.site
+          end
+
+          def call
+            new_tags = new_site_params.fetch(:tags, []) - site.tags
+            site.tags = (site.tags | new_tags) if new_tags.any?
+
+            site.save
+          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}")
+          end
+
+          private
+
+          delegate :netbox_params, :site, to: :context
+
+          def new_site_params
+            netbox_params.fetch(:site, {})
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/foreman_netbox/sync_host/sync_device/update.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncDevice
+      class Update
+        include ::Interactor
+        include ForemanNetbox::Concerns::PrimaryIps
+
+        ATTRIBUTES = %i[name device_role device_type primary_ip4 primary_ip6 site tenant serial tags].freeze
+
+        around do |interactor|
+          interactor.call if context.device
+        end
+
+        before do
+          context.ip_addresses.reload
+        end
+
+        def call
+          assign_new_attributes
+
+          device.save
+        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}")
+        end
+
+        private
+
+        delegate :netbox_params, :device, :device_type, :device_role, :site, :host, to: :context
+        delegate :tenant, to: :context, allow_nil: true
+
+        def new_device_params
+          netbox_params.fetch(:device, {})
+        end
+
+        def assign_new_attributes
+          ATTRIBUTES.map { |attribute| send("assign_#{attribute}") }
+        end
+
+        def assign_name
+          device.name = new_device_params[:name] if device.name != new_device_params[:name]
+        end
+
+        def assign_device_role
+          device.device_role = device_role&.id if device.device_role&.id != device_role&.id
+        end
+
+        def assign_device_type
+          device.device_type = device_type&.id if device.device_type&.id != device_type&.id
+        end
+
+        def assign_primary_ip4
+          device.primary_ip4 = primary_ip4 if device.primary_ip4&.id != primary_ip4
+        end
+
+        def assign_primary_ip6
+          device.primary_ip6 = primary_ip6 if device.primary_ip6&.id != primary_ip6
+        end
+
+        def assign_site
+          device.site = site&.id if device.site&.id != site&.id
+        end
+
+        def assign_tenant
+          device.tenant = tenant&.id if device.tenant&.id != tenant&.id
+        end
+
+        def assign_serial
+          new_serial = new_device_params[:serial]
+          return if !new_serial || device.serial == new_serial
+
+          device.serial = new_serial
+        end
+
+        def assign_tags
+          new_tags = new_device_params.fetch(:tags, []) - device.tags
+
+          device.tags = (device.tags | new_tags) if new_tags.any?
+        end
+      end
+    end
+  end
+end