foreman_netbox 1.0.2

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_cluster/update.rb

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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      module SyncInterfaces
+        class Create
+          include ::Interactor
+
+          after do
+            context.interfaces.reload
+          end
+
+          def call
+            netbox_params.fetch(:interfaces, [])
+                         .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)
+                           ).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
+
+          delegate :virtual_machine, :interfaces, :netbox_params, to: :context
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      module SyncInterfaces
+        class Delete
+          include ::Interactor
+
+          around do |interactor|
+            interactor.call unless context.interfaces.total.zero?
+          end
+
+          def call
+            context.interfaces
+                   .reject { |netbox_interface| interfaces_names.include?(netbox_interface.name) }
+                   .each(&:delete)
+          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 interfaces_names
+            netbox_params.fetch(:interfaces, [])
+                         .map { |i| i[:name] }
+                         .compact
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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_virtual_machine/sync_interfaces/sync_ip_addresses/create.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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_virtual_machine/sync_interfaces/sync_ip_addresses/delete.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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 { |ip| ip.dig(:interface, :name) == netbox_interface.name }
+                                                               .map { |ip| ip.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_virtual_machine/sync_interfaces/sync_ip_addresses/find.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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
+
+            def params
+              {
+                virtual_machine_id: context.virtual_machine.id
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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_virtual_machine/sync_interfaces/sync_ip_addresses/update.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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_virtual_machine/sync_interfaces/update.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      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_virtual_machine/update.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      class Update
+        include ::Interactor
+        include ForemanNetbox::Concerns::PrimaryIps
+
+        ATTRIBUTES = %i[name cluster disk memory primary_ip4 primary_ip6 tenant vcpus tags].freeze
+
+        around do |interactor|
+          interactor.call if context.virtual_machine
+        end
+
+        before do
+          context.ip_addresses.reload
+        end
+
+        def call
+          assign_new_attributes
+
+          virtual_machine.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, :virtual_machine, :cluster, to: :context
+        delegate :tenant, to: :context, allow_nil: true
+
+        def assign_new_attributes
+          ATTRIBUTES.map { |attribute| send("assign_#{attribute}") }
+        end
+
+        def assign_name
+          name = netbox_params.dig(:virtual_machine, :name)
+          virtual_machine.name = name if virtual_machine.name != name
+        end
+
+        def assign_cluster
+          virtual_machine.cluster = cluster.id if virtual_machine.cluster.id != cluster.id
+        end
+
+        def assign_disk
+          disk = netbox_params.dig(:virtual_machine, :disk)
+          virtual_machine.disk = disk if virtual_machine.disk != disk
+        end
+
+        def assign_memory
+          memory = netbox_params.dig(:virtual_machine, :memory)
+          virtual_machine.memory = memory if virtual_machine.memory != memory
+        end
+
+        def assign_primary_ip4
+          virtual_machine.primary_ip4 = primary_ip4 if virtual_machine.primary_ip4&.id != primary_ip4
+        end
+
+        def assign_primary_ip6
+          virtual_machine.primary_ip6 = primary_ip6 if virtual_machine.primary_ip6&.id != primary_ip6
+        end
+
+        def assign_tenant
+          virtual_machine.tenant = tenant&.id if virtual_machine.tenant&.id != tenant&.id
+        end
+
+        def assign_vcpus
+          vcpus = netbox_params.dig(:virtual_machine, :vcpus)
+          virtual_machine.vcpus = vcpus if virtual_machine.vcpus != vcpus
+        end
+
+        def assign_tags
+          new_tags = (netbox_params.dig(:virtual_machine, :tags) || []) - virtual_machine.tags
+
+          virtual_machine.tags = (virtual_machine.tags | new_tags) if new_tags.any?
+        end
+      end
+    end
+  end
+end