foreman_discovery 1.0.0.rc1

data/test/foreman_app/app/models/message.rb

@@ -0,0 +1,19 @@
+class Message < ActiveRecord::Base
+  has_many :reports, :through => :logs
+  has_many :logs
+  validates_presence_of :value, :digest
+
+  def to_s
+    value
+  end
+
+  def as_json(options={})
+    {:message => value }
+  end
+
+  def self.find_or_create val
+    digest = Digest::SHA1.hexdigest(val)
+    Message.where(:digest => digest).first || Message.create(:value => val, :digest => digest)
+  end
+
+end

data/test/foreman_app/app/models/model.rb

@@ -0,0 +1,14 @@
+class Model < ActiveRecord::Base
+  include Authorization
+
+  has_many_hosts
+  has_many :trends, :as => :trendable, :class_name => "ForemanTrend"
+  before_destroy EnsureNotUsedBy.new(:hosts)
+  validates_uniqueness_of :name
+  validates_presence_of :name
+  default_scope :order => 'LOWER(models.name)'
+
+  scoped_search :on => :name, :complete_value => :true, :default_order => true
+  scoped_search :on => :info
+
+end

data/test/foreman_app/app/models/nic.rb

@@ -0,0 +1,61 @@
+# Represents a Host's network interface
+# This class is the both parent
+module Nic
+  class Base < ActiveRecord::Base
+    include Authorization
+    include Foreman::STI
+
+    self.table_name = 'nics'
+
+    attr_accessible :host_id, :host,
+                    :mac, :name,
+                    :_destroy # used for nested_attributes
+
+    before_validation :normalize_mac
+
+    validates_uniqueness_of :mac
+    validates_presence_of :mac
+    validates_format_of :mac, :with => Net::Validations::MAC_REGEXP
+
+    validate :uniq_with_hosts
+
+    validates_presence_of :host
+
+    scope :bootable, where(:type => "Nic::Bootable")
+    scope :bmc, where(:type => "Nic::BMC")
+    scope :interfaces, where(:type => "Nic::Interface")
+    scope :managed, where(:type => "Nic::Managed")
+
+    belongs_to_host :inverse_of => :interfaces, :class_name => "Host::Managed"
+    # keep extra attributes needed for sub classes.
+    serialize :attrs, Hash
+
+    protected
+
+    def uniq_fields_with_hosts
+      [:mac]
+    end
+
+    # make sure we don't have a conflicting interface with an host record
+    def uniq_with_hosts
+      failed = false
+      uniq_fields_with_hosts.each do |attr|
+        value = self.send(attr)
+        unless value.blank?
+          if host.send(attr) == value
+            errors.add(attr, _("Can't use the same value as the primary interface"))
+            failed = true
+          elsif Host.where(attr => value).limit(1).pluck(attr).any?
+            errors.add(attr, _("already in use"))
+            failed = true
+          end
+        end
+      end
+      !failed
+    end
+
+    def normalize_mac
+      self.mac = Net::Validations.normalize_mac(mac)
+    end
+  end
+end

data/test/foreman_app/app/models/nic/bmc.rb

@@ -0,0 +1,22 @@
+module Nic
+  class BMC < Managed
+
+    ATTRIBUTES = [:username, :password, :provider]
+    attr_accessible *ATTRIBUTES
+
+    PROVIDERS = %w(IPMI)
+    validates_inclusion_of :provider, :in => PROVIDERS
+
+    ATTRIBUTES.each do |method|
+      define_method method do
+        self.attrs ||= { }
+        self.attrs[method]
+      end
+
+      define_method "#{method}=" do |value|
+        self.attrs         ||= { }
+        self.attrs[method] = value
+      end
+    end
+  end
+end

data/test/foreman_app/app/models/nic/bootable.rb

@@ -0,0 +1,31 @@
+module Nic
+  class Bootable < Managed
+
+    delegate :tftp?, :tftp, :to => :subnet
+    delegate :jumpstart?, :build?, :to => :host
+
+    # ensure that we can only have one bootable interface
+    validates_uniqueness_of :type, :scope => :host_id, :message => N_("Only one bootable interface is allowed")
+
+    def dhcp_record
+      return unless dhcp? or @dhcp_record
+      @dhcp_record ||= host.jumpstart? ? Net::DHCP::SparcRecord.new(dhcp_attrs) : Net::DHCP::Record.new(dhcp_attrs)
+    end
+
+    protected
+
+    def dhcp_attrs
+      attrs = super.merge({
+                            :filename   => host.operatingsystem.boot_filename(host),
+                            :nextServer => boot_server
+                          })
+      # Are we booting SPARC solaris?
+      if host.jumpstart?
+        jumpstart_arguments = host.os.jumpstart_params host, host.model.vendor_class
+        attrs.merge! jumpstart_arguments unless jumpstart_arguments.empty?
+      end
+      attrs
+    end
+
+  end
+end

data/test/foreman_app/app/models/nic/interface.rb

@@ -0,0 +1,23 @@
+module Nic
+  class Interface < Base
+
+    attr_accessible :ip
+
+    validates_uniqueness_of :ip
+    validates_presence_of :ip
+    validates_format_of :ip, :with => Net::Validations::IP_REGEXP
+
+    validate :normalize_ip
+
+    protected
+
+    def uniq_fields_with_hosts
+      [:mac, :ip]
+    end
+
+    def normalize_ip
+      self.ip = Net::Validations.normalize_ip(ip)
+    end
+
+  end
+end

data/test/foreman_app/app/models/nic/managed.rb

@@ -0,0 +1,57 @@
+module Nic
+  class Managed < Interface
+    include Orchestration
+    include Orchestration::DHCP
+    include Orchestration::DNS
+
+    attr_accessible :name, :subnet_id, :subnet, :domain_id, :domain
+
+    validates_uniqueness_of :name, :scope => :domain_id
+
+    belongs_to :subnet
+    belongs_to :domain
+
+    delegate :vlanid, :network, :to => :subnet
+
+    # 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 :progress_report_id, :require_ip_validation?, :overwrite?, :capabilities, :managed?, :to => :host
+
+    # this ensures we can create an interface even when there is no host queue
+    # e.g. outside to Host nested attributes
+    def queue_with_host
+      if host
+        logger.debug 'Using host queue'
+        host.queue
+      else
+        logger.debug 'Using nic queue'
+        queue_without_host
+      end
+    end
+    alias_method_chain :queue, :host
+
+    # returns a DHCP reservation object
+    def dhcp_record
+      return unless dhcp? or @dhcp_record
+      @dhcp_record ||= Net::DHCP::Record.new(dhcp_attrs)
+    end
+
+    protected
+
+    def uniq_fields_with_hosts
+      [:mac, :ip, :name]
+    end
+
+    # returns a hash of dhcp record attributes
+    def dhcp_attrs
+      raise ::Foreman::Exception.new(N_("DHCP not supported for this NIC")) unless dhcp?
+      {
+        :hostname => name,
+        :ip       => ip,
+        :mac      => mac,
+        :proxy    => subnet.dhcp_proxy,
+        :network  => network
+      }
+    end
+  end
+end

data/test/foreman_app/app/models/notice.rb

@@ -0,0 +1,36 @@
+class Notice < ActiveRecord::Base
+  has_and_belongs_to_many :users, :join_table =>'user_notices'
+
+  TYPES = %w{message warning}
+  before_validation :set_default_notice_level
+  validates_inclusion_of :level, :in => TYPES
+
+  validates_presence_of :content
+  before_save :add_to_users
+
+  def to_s
+    "#{global? ? "global" : "individual"} #{content}"
+  end
+
+  def destroy_notice
+    if global
+      destroy
+    else
+      users.delete(User.current)
+      destroy unless users.any?
+    end
+  end
+  private
+
+  def add_to_users
+    if global
+      self.users = [User.current]
+    else
+      self.users = User.all
+    end
+  end
+
+  def set_default_notice_level
+    self.level ||= TYPES.first
+  end
+end

data/test/foreman_app/app/models/operatingsystem.rb

@@ -0,0 +1,196 @@
+require 'ostruct'
+require 'uri'
+
+class Operatingsystem < ActiveRecord::Base
+  include Authorization
+
+  has_many_hosts
+  has_many :images, :dependent => :destroy
+  has_and_belongs_to_many :media
+  has_and_belongs_to_many :ptables
+  has_and_belongs_to_many :architectures
+  has_and_belongs_to_many :puppetclasses
+  has_and_belongs_to_many :config_templates
+  has_many :os_default_templates, :dependent => :destroy
+  accepts_nested_attributes_for :os_default_templates, :allow_destroy => true,
+    :reject_if => lambda { |v| v[:config_template_id].blank? }
+
+  validates_presence_of :major, :message => N_("Operating System version is required")
+  has_many :os_parameters, :dependent => :destroy, :foreign_key => :reference_id
+  has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "OsParameter"
+  accepts_nested_attributes_for :os_parameters, :reject_if => lambda { |a| a[:value].blank? }, :allow_destroy => true
+  has_many :trends, :as => :trendable, :class_name => "ForemanTrend"
+  validates_numericality_of :major
+  validates_numericality_of :minor, :allow_nil => true, :allow_blank => true
+  validates_format_of :name, :with => /\A(\S+)\Z/, :message => N_("can't be blank or contain white spaces.")
+  before_validation :downcase_release_name
+  #TODO: add validation for name and major uniqueness
+
+  before_destroy EnsureNotUsedBy.new(:hosts)
+  before_save :deduce_family
+  audited
+  default_scope :order => 'LOWER(operatingsystems.name)'
+
+  scoped_search :on => :name, :complete_value => :true
+  scoped_search :on => :major, :complete_value => :true
+  scoped_search :on => :minor, :complete_value => :true
+  scoped_search :on => :type, :complete_value => :true, :rename => "family"
+
+  scoped_search :in => :architectures,    :on => :name, :complete_value => :true, :rename => "architecture"
+  scoped_search :in => :media,            :on => :name, :complete_value => :true, :rename => "medium"
+  scoped_search :in => :config_templates, :on => :name, :complete_value => :true, :rename => "template"
+  scoped_search :in => :os_parameters,    :on => :value, :on_key=> :name, :complete_value => true, :rename => :params
+
+  FAMILIES = { 'Debian'  => %r{Debian|Ubuntu}i,
+               'Redhat'  => %r{RedHat|Centos|Fedora|Scientific|SLC}i,
+               'Suse'    => %r{OpenSuSE}i,
+               'Windows' => %r{Windows}i,
+               'Archlinux' => %r{Archlinux}i,
+               'Solaris' => %r{Solaris}i }
+
+  class Jail < Safemode::Jail
+    allow :name, :media_url, :major, :minor, :family, :to_s, :epel, :==, :release_name, :kernel, :initrd, :pxe_type, :medium_uri
+  end
+
+  # As Rails loads an object it casts it to the class in the 'type' field. If we ensure that the type and
+  # family are the same thing then rails converts the record to a Debian or a solaris object as required.
+  # Manually managing the 'type' field allows us to control the inheritance chain and the available methods
+  def family
+    read_attribute(:type)
+  end
+
+  def family=(value)
+    self.type = value
+  end
+
+  def self.families
+    FAMILIES.keys.sort
+  end
+
+  def self.families_as_collection
+    families.map{|e| OpenStruct.new(:name => e, :value => e) }
+  end
+
+  def medium_uri host, url = nil
+    url ||= host.medium.path
+    medium_vars_to_uri(url, host.architecture.name, host.os)
+  end
+
+  def medium_vars_to_uri (url, arch, os)
+    URI.parse(interpolate_medium_vars(url, arch, os)).normalize
+  end
+
+  def interpolate_medium_vars path, arch, os
+    return "" if path.empty?
+
+    path.gsub('$arch',  arch).
+         gsub('$major',  os.major).
+         gsub('$minor',  os.minor).
+         gsub('$version', [os.major, os.minor ].compact.join('.')).
+         gsub('$release', os.release_name ? os.release_name : "" )
+  end
+
+  # The OS is usually represented as the concatenation of the OS and the revision
+  def to_label
+    "#{name} #{release}"
+  end
+
+  def release
+    "#{major}#{('.' + minor) unless minor.empty?}"
+  end
+
+  def to_s
+    to_label
+  end
+
+  def fullname
+    to_label
+  end
+
+  # sets the prefix for the tfp files based on the os / arch combination
+  def pxe_prefix(arch)
+    "boot/#{to_s}-#{arch}".gsub(" ","-")
+  end
+
+  def pxe_files(medium, arch)
+    boot_files_uri(medium, arch).collect do |img|
+      { pxe_prefix(arch).to_sym => img.to_s}
+    end
+  end
+
+  def as_json(options={})
+    {:operatingsystem => {:name => to_s, :id => id, :media => media, :architectures => architectures, :ptables => ptables, :config_templates => config_templates}}
+  end
+
+  def kernel arch
+    bootfile(arch,:kernel)
+  end
+
+  def initrd arch
+    bootfile(arch,:initrd)
+  end
+
+  def bootfile arch, type
+    pxe_prefix(arch) + "-" + eval("#{self.family}::PXEFILES[:#{type}]")
+  end
+
+  # Does this OS family support a build variant that is constructed from a prebuilt archive
+  def supports_image
+    false
+  end
+
+  # override in sub operatingsystem classes as required.
+  def pxe_variant
+    "syslinux"
+  end
+
+  # The kind of PXE configuration template used. PXELinux and PXEGrub are currently supported
+  def template_kind
+    "PXELinux"
+  end
+
+  #handle things like gpxelinux/ gpxe / pxelinux here
+  def boot_filename host=nil
+    "pxelinux.0"
+  end
+
+  # Does this OS family use release_name in its naming scheme
+  def use_release_name?
+    false
+  end
+
+  def image_extension
+    raise ::Foreman::Exception(N_("Attempting to construct an operating system image filename but %s cannot be built from an image"), family)
+  end
+
+  # If this OS family requires access to its media via NFS
+  def require_nfs_access_to_medium
+    false
+  end
+
+  private
+  def deduce_family
+    if self.family.blank?
+      found = nil
+      for f in self.class.families
+        if name =~ FAMILIES[f]
+          found = f
+        end
+      end
+      self.family = found
+    end
+  end
+
+  def downcase_release_name
+    self.release_name.downcase! unless defined?(Rake) or release_name.nil? or release_name.empty?
+  end
+
+  def boot_files_uri(medium, architecture)
+    raise (_("invalid medium for %s") % to_s) unless media.include?(medium)
+    raise (_("invalid architecture for %s") % to_s) unless architectures.include?(architecture)
+    eval("#{self.family}::PXEFILES").values.collect do |img|
+      medium_vars_to_uri("#{medium.path}/#{pxedir}/#{img}", architecture.name, self)
+    end
+  end
+
+end