theforeman/foreman

module Nic
  class Managed < Interface
    include Orchestration
    include Orchestration::DHCP
    include Orchestration::DNS
    include Orchestration::TFTP
    include Orchestration::ExternalIPAM
    include DnsInterface
    include InterfaceCloning

    include Exportable

    before_validation :set_provisioning_flag
    after_save :update_lookup_value_fqdn_matchers, :drop_host_cache

    validates :ip, :belongs_to_subnet => {:subnet => :subnet }, :if => ->(nic) { nic.managed? }
    validates :ip6, :belongs_to_subnet => {:subnet => :subnet6 }, :if => ->(nic) { nic.managed? }

    validates :compute_resource, :belongs_to_host_taxonomy => { :taxonomy => :organization },
              :if => ->(nic) { nic.host.respond_to?(:compute_resource) }
    validates :compute_resource, :belongs_to_host_taxonomy => { :taxonomy => :location },
              :if => ->(nic) { nic.host.respond_to?(:compute_resource) }

    # Interface normally are not executed by them self, so we use the host queue and related methods.
    # this ensures our orchestration works on both a host and a managed interface
    delegate :capabilities, :compute_resource, :operatingsystem, :provisioning_template, :jumpstart?, :build, :build?, :os, :arch,
      :image_build?, :pxe_build?, :pxe_build?, :token, :model, :to => :host
    delegate :operatingsystem_id, :hostgroup_id, :overwrite?,
      :skip_orchestration?, :skip_orchestration!, :to => :host, :allow_nil => true

    attr_exportable :ip, :ip6, :mac, :name, :attrs, :virtual, :link, :identifier, :managed,
      :primary, :provision, :subnet, :subnet6,
      :tag => ->(nic) { nic.tag if nic.virtual? },
      :attached_to => ->(nic) { nic.attached_to if nic.virtual? },
      :type => ->(nic) { nic.type.constantize.humanized_name }

    # this ensures we can create an interface even when there is no host queue
    # e.g. outside to Host nested attributes
    def queue
      if host&.respond_to?(:queue)
        host.queue
      else
        super
      end
    end

    def progress_report_id
      if host&.respond_to?(:progress_report_id)
        host.progress_report_id
      else
        super
      end
    end

    def progress_report_id=(value)
      if host&.respond_to?(:progress_report_id=)
        host.progress_report_id = value
      else
        super
      end
    end

    def self.humanized_name
      N_('Interface')
    end

    def ip_available?
      ip.present? || compute_provides_ip?(:ip)
    end

    def ip6_available?
      ip6.present? || compute_provides_ip?(:ip6)
    end

    def mac_available?
      mac_addresses_for_provisioning.any? || (host.present? && host.compute_provides?(:mac))
    end

    protected

    def copy_hostname_from_host
      self.name = host.read_attribute :name
    end

    def set_provisioning_flag
      return unless primary?
      return unless host.present?
      self.provision = true if host.interfaces.detect(&:provision).nil?
    end

    def update_lookup_value_fqdn_matchers
      return unless primary?
      return unless saved_change_to_fqdn?
      return unless host.present?
      LookupValue.where(:match => "fqdn=#{fqdn_before_last_save}").
        update_all(:match => host.lookup_value_match)
    end

    def drop_host_cache
      return unless host.present?
      host.drop_primary_interface_cache   if primary?
      host.drop_provision_interface_cache if provision?
      true
    end

    # log errors to host object since we can't read it later (even if host.destroy fails host.interfaces is
    # always set to [] so we lose interfaces errors)
    def failure(msg, exception_or_backtrace = nil, dest = :base)
      result = super
      host.errors.add(dest, msg)
      result
    end

    # we must also clone host object so we can detect host attributes changes
    def setup_clone
      return if new_record?
      @old = super
      @old.host = host.setup_clone
      @old
    end
  end

  Base.register_type(Managed)
end

require_dependency 'nic/bmc'
require_dependency 'nic/bond'
require_dependency 'nic/bridge'