foreman_netbox 1.0.2

data/app/interactors/foreman_netbox/sync_host/sync_virtual_machine/validate.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module SyncHost
+    module SyncVirtualMachine
+      class Validate
+        include ::Interactor
+
+        def call
+          validator = ForemanNetbox::VirtualMachineContract.new.call(netbox_params)
+
+          return if validator.success?
+
+          message = validator.errors
+                             .messages
+                             .map { |m| "#{m.path} #{m.text}" }
+                             .to_sentence
+          context.fail!(error: _('Invalid Virtual Machine parameters: %s') % message)
+        end
+
+        delegate :netbox_params, to: :context
+      end
+    end
+  end
+end

data/app/jobs/foreman_netbox/sync_host_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  class SyncHostJob < ::ApplicationJob
+    queue_as :netbox_queue
+
+    def perform(host_id)
+      Host::Managed.find(host_id)&.push_to_netbox
+    end
+
+    rescue_from(StandardError) do |error|
+      Foreman::Logging.logger('background').error("Netbox: Error #{error}: #{error.backtrace}")
+    end
+
+    def humanized_name
+      _('Push host to Netbox')
+    end
+  end
+end

data/app/lib/foreman_netbox/api.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  class API
+    def self.client
+      NetboxClientRuby.configure do |config|
+        config.netbox.api_base_url = "#{Setting::Netbox['netbox_url']}/api"
+        config.netbox.auth.token = Setting::Netbox['netbox_api_token']
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_netbox/host_extensions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module HostExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      include ::Orchestration::Netbox
+    end
+
+    def netbox_facet
+      @netbox_facet ||= super || ForemanNetbox::NetboxFacet.new(host: self)
+    end
+
+    def push_to_netbox_async
+      ForemanNetbox::SyncHostJob.perform_later(id)
+    end
+
+    def push_to_netbox
+      ForemanNetbox::SyncHost::Organizer.call(host: self)
+    end
+
+    def delete_from_netbox
+      ForemanNetbox::DeleteHost::Organizer.call(host: self)
+    end
+  end
+end

data/app/models/concerns/foreman_netbox/location_extensions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module LocationExtensions
+    def netbox_site_name
+      parameters.fetch('netbox_site', name)
+    end
+
+    def netbox_site_slug
+      netbox_site_name&.parameterize
+    end
+  end
+end

data/app/models/concerns/foreman_netbox/nic/base_extensions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module Nic
+    module BaseExtensions
+      def netbox_name
+        identifier || (mac && "Interface #{mac}")
+      end
+
+      def netbox_ips
+        [netbox_ip, netbox_ip6].compact
+      end
+
+      def netbox_ip
+        ip && subnet && "#{ip}/#{subnet.cidr}"
+      end
+
+      def netbox_ip6
+        ip6 && subnet6 && "#{ip6}/#{subnet6.cidr}"
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_netbox/user_usergroup_common_extensions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  module UserUsergroupCommonExtensions
+    NETBOX_TENANT_MAX_LENGTH = 30
+
+    def netbox_tenant_name
+      return name unless name.length > NETBOX_TENANT_MAX_LENGTH
+
+      name_length = NETBOX_TENANT_MAX_LENGTH - id.to_s.length - 1
+      "#{name.to_s.truncate(name_length, omission: '')}-#{id}"
+    end
+
+    def netbox_tenant_slug
+      netbox_tenant_name&.parameterize
+    end
+  end
+end

data/app/models/foreman_netbox/netbox_facet.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  class NetboxFacet < ApplicationRecord
+    include Facets::Base
+
+    COMMON_PARAMS = %i[interfaces ip_addresses tenant].freeze
+    DEVICE_PARAMS = %i[device device_role device_type manufacturer site].freeze
+    VIRTUAL_MACHINE_PARAMS = %i[virtual_machine cluster cluster_type].freeze
+
+    validates :host, presence: true, allow_blank: false
+    validates :url, uniqueness: true
+
+    def synchronization_success?
+      !synchronization_error
+    end
+
+    def netbox_params
+      ForemanNetbox::NetboxParameters.call(host)
+    end
+
+    def cached_netbox_params
+      ForemanNetbox::CachedNetboxParameters.call(host)
+    end
+
+    def netbox_params_diff
+      ForemanNetbox::NetboxParametersComparator.call(cached_netbox_params, netbox_params)
+    end
+
+    def netbox_will_change?
+      netbox_params_diff.keys.any?
+    end
+  end
+end

data/app/models/orchestration/netbox.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Netbox
+    extend ActiveSupport::Concern
+
+    included do
+      after_validation :queue_netbox_push, if: :netbox_orchestration_allowed?
+      before_destroy :queue_netbox_destroy
+    end
+
+    delegate :netbox_will_change?, :netbox_params_diff, to: :netbox_facet
+
+    protected
+
+    def netbox_orchestration_allowed?
+      Setting::Netbox[:netbox_orchestration_enabled] && netbox_will_change?
+    end
+
+    def queue_netbox_push
+      return unless errors.empty? && managed?
+
+      ::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])
+    end
+
+    def queue_netbox_destroy
+      return unless errors.empty? && managed?
+
+      queue.create(name: _('Delete host %s from Netbox') % self, priority: 60,
+                   action: [self, :del_netbox])
+    end
+
+    def set_netbox
+      ::Foreman::Logging.logger('foreman_netbox/import')
+                        .info("Pushing #{name} to Netbox")
+
+      push_to_netbox_async
+    rescue StandardError => e
+      ::Foreman::Logging.logger('foreman_netbox/import')
+                        .error("Failed to push #{name} to Netbox. Error #{e}: #{e.backtrace}")
+
+      failure format(_('Failed to push %{name} to Netbox: %{message}\n '), name: name, message: e.message), e
+    end
+
+    def del_netbox
+      ::Foreman::Logging.logger('foreman_netbox/import')
+                        .info("Deleting #{name} from Netbox")
+
+      result = delete_from_netbox
+      return true if result.success?
+
+      raise Foreman::Exception, result.error
+    rescue StandardError => e
+      ::Foreman::Logging.logger('foreman_netbox/import')
+                        .error("Failed to delete #{name} from Netbox. Error #{e}: #{e.backtrace}")
+
+      failure format(_('Failed to delete %{name} from Netbox: %{message}\n '), name: name, message: e.message), e
+    end
+  end
+end

data/app/models/setting/netbox.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Setting
+  class Netbox < ::Setting
+    BLANK_ATTRS << 'netbox_url'
+    BLANK_ATTRS << 'netbox_api_token'
+    URI_BLANK_ATTRS << 'netbox_url'
+
+    def self.default_settings
+      [
+        set('netbox_url', N_('URL where Netbox is reachable'), nil, N_('Netbox URL')),
+        set('netbox_api_token', N_('API token to Netbox'), nil, N_('Netbox API token'), nil, encrypted: true),
+        set('netbox_orchestration_enabled', N_('Enable Netbox Orchestration'), false, N_('Netbox Orchestration'))
+      ]
+    end
+
+    def self.load_defaults
+      # Check the table exists
+      return unless super
+
+      transaction do
+        default_settings.each { |s| create! s.update(category: 'Setting::Netbox') }
+      end
+
+      true
+    end
+
+    def self.humanized_category
+      N_('Netbox')
+    end
+  end
+end

data/app/services/foreman_netbox/cached_netbox_parameters.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  class CachedNetboxParameters
+    def self.call(host)
+      new(host).call
+    end
+
+    def initialize(host)
+      @is_compute = host.compute?
+      @data = host.netbox_facet.raw_data&.deep_symbolize_keys || {}
+      @result = {}
+    end
+
+    def call
+      additional_params = is_compute ? ForemanNetbox::NetboxFacet::VIRTUAL_MACHINE_PARAMS : ForemanNetbox::NetboxFacet::DEVICE_PARAMS
+      (ForemanNetbox::NetboxFacet::COMMON_PARAMS + additional_params).map { |key| send("read_#{key}") }
+
+      result
+    end
+
+    private
+
+    attr_reader :data, :is_compute
+    attr_accessor :result
+
+    def read_interfaces
+      return unless data.keys.include?(:interfaces)
+
+      result[:interfaces] = data.fetch(:interfaces, {}).fetch(:results, []).map do |interface|
+        interface.slice(:name, :mac_address, :tags)
+                 .merge(type: interface.fetch(:type, {}).slice(:value))
+                 .compact
+      end
+    end
+
+    def read_ip_addresses
+      return unless data.keys.include?(:ip_addresses)
+
+      result[:ip_addresses] = data.fetch(:ip_addresses, {}).fetch(:results, []).map do |ip_address|
+        ip_address.slice(:address, :tags)
+                  .merge(interface: ip_address.fetch(:interface, {}).slice(:name))
+      end
+    end
+
+    def read_virtual_machine
+      return unless data.keys.include?(:virtual_machine)
+
+      result[:virtual_machine] = data.fetch(:virtual_machine, {}).slice(:name, :vcpus, :memory, :disk, :tags)
+    end
+
+    def read_tenant
+      return unless data.keys.include?(:tenant)
+
+      result[:tenant] = data.fetch(:tenant, {}).slice(:name, :slug, :tags)
+    end
+
+    def read_cluster
+      return unless data.keys.include?(:cluster)
+
+      result[:cluster] = data.fetch(:cluster, {}).slice(:name, :tags)
+    end
+
+    def read_cluster_type
+      return unless data.keys.include?(:cluster_type)
+
+      result[:cluster_type] = data.fetch(:cluster_type, {}).slice(:name, :slug)
+    end
+
+    def read_device
+      return unless data.keys.include?(:device)
+
+      result[:device] = data.fetch(:device, {})
+                            .slice(:name, :serial, :tags)
+                            .compact
+                            .reject { |k, v| k == :serial && v.blank? }
+    end
+
+    def read_device_role
+      return unless data.keys.include?(: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)
+
+      result[:device_type] = data.fetch(:device_type, {}).slice(:model, :slug, :tags)
+    end
+
+    def read_manufacturer
+      return unless data.keys.include?(:manufacturer)
+
+      result[:manufacturer] = data.fetch(:manufacturer, {}).slice(:name, :slug)
+    end
+
+    def read_site
+      return unless data.keys.include?(:site)
+
+      result[:site] = data.fetch(:site, {}).slice(:name, :slug, :tags)
+    end
+  end
+end

data/app/services/foreman_netbox/netbox_parameters.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module ForemanNetbox
+  # rubocop:disable Metrics/ClassLength
+  class NetboxParameters
+    UNKNOWN = 'Unknown'
+    DEFAULT_TAGS = ['foreman'].freeze
+    DEFAULT_INTERFACE_TYPE = 'virtual'
+    CLUSTER_TYPES = {
+      :'Foreman::Model::Vmware' => {
+        name: 'VMware ESXi',
+        slug: 'vmware-esxi'
+      }
+    }.freeze
+    DEVICE_ROLE = {
+      name: 'SERVER',
+      color: '9e9e9e',
+      slug: 'server'
+    }.freeze
+
+    def self.call(host)
+      new(host).call
+    end
+
+    def initialize(host)
+      @host = host
+    end
+
+    def call
+      additional_params = host.compute? ? ForemanNetbox::NetboxFacet::VIRTUAL_MACHINE_PARAMS : ForemanNetbox::NetboxFacet::DEVICE_PARAMS
+
+      (ForemanNetbox::NetboxFacet::COMMON_PARAMS + additional_params).map do |param|
+        send(param)
+      end.reduce({}, :merge)
+    end
+
+    private
+
+    attr_accessor :host
+
+    delegate :netbox_facet, to: :host
+    delegate :cached_netbox_params, to: :netbox_facet
+
+    def netbox_compute_attributes
+      @netbox_compute_attributes ||= host.compute_object.yield_self do |compute_object|
+        {
+          vcpus: compute_object&.cpus,
+          memory: compute_object&.memory_mb,
+          disk: compute_object&.volumes&.map(&:size_gb)&.reduce(&:+),
+          cluster: compute_object&.cluster
+        }.compact
+      end
+    end
+
+    def tenant
+      {
+        tenant: {
+          name: host.owner&.netbox_tenant_name,
+          slug: host.owner&.netbox_tenant_slug,
+          tags: DEFAULT_TAGS
+        }
+      }
+    end
+
+    def device
+      {
+        device: {
+          name: host.name,
+          serial: host.facts.deep_symbolize_keys[:serialnumber],
+          tags: DEFAULT_TAGS
+        }
+      }
+    end
+
+    def device_role
+      {
+        device_role: DEVICE_ROLE
+      }
+    end
+
+    def device_type
+      model = host.facts.deep_symbolize_keys[:productname] || host.facts.deep_symbolize_keys[:'dmi::product::name'] || UNKNOWN
+
+      {
+        device_type: {
+          model: model,
+          slug: model.parameterize,
+          tags: DEFAULT_TAGS
+        }
+      }
+    end
+
+    def manufacturer
+      name = host.facts.deep_symbolize_keys[:manufacturer] || host.facts.deep_symbolize_keys[:'dmi::manufacturer'] || UNKNOWN
+
+      {
+        manufacturer: {
+          name: name,
+          slug: cached_netbox_params.dig(:manufacturer, :slug) || name.parameterize
+        }
+      }
+    end
+
+    def site
+      {
+        site: {
+          name: host.location&.netbox_site_name,
+          slug: host.location&.netbox_site_slug,
+          tags: DEFAULT_TAGS
+        }
+      }
+    end
+
+    def interfaces
+      {
+        interfaces: host.interfaces.map do |interface|
+          identifier = interface.identifier.present? && interface.identifier
+          mac_address = interface.mac&.upcase
+
+          {
+            name: identifier || (mac_address && "Interface #{mac_address}"),
+            mac_address: mac_address,
+            type: {
+              value: DEFAULT_INTERFACE_TYPE
+            },
+            tags: DEFAULT_TAGS
+          }
+        end
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    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}"
+          ].compact.map do |ip_address|
+            identifier = interface.identifier.present? && interface.identifier
+            mac_address = interface.mac&.upcase
+
+            {
+              address: ip_address,
+              interface: {
+                name: identifier || (mac_address && "Interface #{mac_address}")
+              },
+              tags: DEFAULT_TAGS
+            }
+          end
+        end.flatten
+      }
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def virtual_machine
+      {
+        virtual_machine: netbox_compute_attributes.slice(
+          :vcpus, :memory, :disk
+        ).merge(
+          name: host.name,
+          tags: DEFAULT_TAGS
+        )
+      }
+    end
+
+    def cluster
+      {
+        cluster: {
+          name: netbox_compute_attributes[:cluster],
+          tags: DEFAULT_TAGS
+        }.compact
+      }
+    end
+
+    def cluster_type
+      type = host.compute_resource&.type&.to_sym
+
+      {
+        cluster_type: CLUSTER_TYPES.fetch(type, nil)
+      }
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end