|
require 'ostruct'
|
|
require 'uri'
|
|
|
|
class Operatingsystem < ApplicationRecord
|
|
audited
|
|
include Authorizable
|
|
include ValidateOsFamily
|
|
include PxeLoaderSupport
|
|
extend FriendlyId
|
|
friendly_id :title
|
|
|
|
validates_lengths_from_database
|
|
before_destroy EnsureNotUsedBy.new(:hosts, :hostgroups)
|
|
has_many_hosts
|
|
has_many :hostgroups
|
|
has_many :images, :dependent => :destroy
|
|
has_and_belongs_to_many :media
|
|
has_and_belongs_to_many :ptables, :join_table => :operatingsystems_ptables, :foreign_key => :operatingsystem_id, :association_foreign_key => :ptable_id
|
|
has_and_belongs_to_many :architectures
|
|
has_and_belongs_to_many :provisioning_templates, :join_table => :operatingsystems_provisioning_templates, :foreign_key => :operatingsystem_id, :association_foreign_key => :provisioning_template_id
|
|
has_many :os_default_templates, :dependent => :destroy
|
|
accepts_nested_attributes_for :os_default_templates, :allow_destroy => true,
|
|
:reject_if => :reject_empty_provisioning_template
|
|
|
|
validates :major, numericality: true, presence: { message: N_("Operating System version is required") }
|
|
validates :minor, format: { with: /\A\d+(\.\d+)*\z/, message: "Operating System minor version must be in N or N.N format" }, allow_blank: true
|
|
has_many :os_parameters, :dependent => :destroy, :foreign_key => :reference_id, :inverse_of => :operatingsystem
|
|
has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "OsParameter"
|
|
accepts_nested_attributes_for :os_parameters, :allow_destroy => true
|
|
include ParameterValidators
|
|
include ScopedSearchExtensions
|
|
include ParameterSearch
|
|
|
|
attr_name :to_label
|
|
validates :name, :presence => true, :no_whitespace => true,
|
|
:uniqueness => { :scope => [:major, :minor], :message => N_("Operating system version already exists")}
|
|
validates :description, :uniqueness => true, :allow_blank => true
|
|
validates :password_hash, :inclusion => { :in => PasswordCrypt::ALGORITHMS }
|
|
validates :release_name, :presence => true, :if => proc { |os| os.family == 'Debian' }
|
|
before_validation :downcase_release_name, :set_title, :stringify_major_and_minor
|
|
validates :title, :uniqueness => true, :presence => true
|
|
|
|
before_validation :set_family
|
|
|
|
after_create :assign_init_config_template
|
|
|
|
default_scope -> { order(:title) }
|
|
|
|
scoped_search :on => :id, :complete_enabled => false, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
|
|
scoped_search :on => :name, :complete_value => :true
|
|
scoped_search :on => :major, :complete_value => :true
|
|
scoped_search :on => :minor, :complete_value => :true
|
|
scoped_search :on => :description, :complete_value => :true
|
|
scoped_search :on => :type, :complete_value => :true, :rename => "family"
|
|
scoped_search :on => :title, :complete_value => :true
|
|
|
|
scoped_search :relation => :architectures, :on => :name, :complete_value => :true, :rename => "architecture", :only_explicit => true
|
|
scoped_search :relation => :media, :on => :name, :complete_value => :true, :rename => "medium", :only_explicit => true
|
|
scoped_search :relation => :provisioning_templates, :on => :name, :complete_value => :true, :rename => "template", :only_explicit => true
|
|
|
|
FAMILIES = { 'Debian' => %r{Debian|Ubuntu}i,
|
|
'Redhat' => %r{RedHat|Centos|Fedora|Scientific|SLC|OracleLinux|AlmaLinux|Rocky|Amazon}i,
|
|
'Suse' => %r{OpenSuSE|SLES|SLED}i,
|
|
'Windows' => %r{Windows}i,
|
|
'Altlinux' => %r{Altlinux}i,
|
|
'Archlinux' => %r{Archlinux}i,
|
|
'Coreos' => %r{CoreOS|Flatcar}i,
|
|
'Fcos' => %r{FCOS|FedoraCoreOS|FedoraCOS}i,
|
|
'Rhcos' => %r{RHCOS|RedHatCoreOS|RedHatCOS}i,
|
|
'Rancheros' => %r{RancherOS}i,
|
|
'Gentoo' => %r{Gentoo}i,
|
|
'Solaris' => %r{Solaris}i,
|
|
'Freebsd' => %r{FreeBSD}i,
|
|
'AIX' => %r{AIX}i,
|
|
'Junos' => %r{Junos}i,
|
|
'VRP' => %r{VRP}i,
|
|
'NXOS' => %r{NX-OS}i,
|
|
'Xenserver' => %r{XenServer}i }
|
|
|
|
graphql_type '::Types::Operatingsystem'
|
|
|
|
apipie :class do
|
|
sections only: %w[all additional]
|
|
prop_group :basic_model_props, ApplicationRecord, meta: { friendly_name: 'operating system consisting', example: 'RedHat, Fedora, Debian' }
|
|
property :major, String, desc: 'Major version of the operating system'
|
|
property :minor, String, desc: 'Minor version of the operating system'
|
|
property :family, String, desc: 'Family of the operating system, e.g. Redhat'
|
|
property :to_s, String, desc: 'Returns full name of the operating system, e.g. CentOS 7.0'
|
|
property :release, String, desc: 'Full release version, e.g. 7.0'
|
|
property :release_name, String, desc: 'Release name of the operating system, e.g. stretch'
|
|
property :pxe_type, String, desc: 'PXE type of the operating system, e.g. kickstart'
|
|
property :password_hash, String, desc: 'Encrypted hash of the operating system password'
|
|
end
|
|
class Jail < Safemode::Jail
|
|
allow :id, :name, :major, :minor, :family, :to_s, :==, :release, :release_name, :kernel, :initrd, :pxe_type, :boot_files_uri, :password_hash, :mediumpath, :bootfile
|
|
end
|
|
|
|
def self.title_name
|
|
"title".freeze
|
|
end
|
|
|
|
def additional_media(medium_provider)
|
|
medium_provider.additional_media.map(&:with_indifferent_access)
|
|
end
|
|
|
|
def self.inherited(child)
|
|
child.instance_eval do
|
|
# Ensure all subclasses behave in the same way as the parent, and remain
|
|
# identified as Operatingsystems instead of subclasses in UI paths etc.
|
|
#
|
|
# rubocop:disable Rails/Delegate
|
|
def model_name
|
|
superclass.model_name
|
|
end
|
|
# rubocop:enable Rails/Delegate
|
|
end
|
|
super
|
|
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
|
|
self[:type]
|
|
end
|
|
|
|
def family=(value)
|
|
self.type = value
|
|
end
|
|
|
|
def self.families
|
|
FAMILIES.keys.sort
|
|
end
|
|
validate_inclusion_in_families :type
|
|
|
|
def self.families_as_collection
|
|
families.map do |f|
|
|
OpenStruct.new(:name => f.constantize.new.display_family, :value => f)
|
|
end
|
|
end
|
|
|
|
# The OS is usually represented as the concatenation of the OS and the revision
|
|
def to_label
|
|
return description if description.present?
|
|
fullname
|
|
end
|
|
|
|
# to_label setter updates description and does not try to parse and update major, minor attributes
|
|
def to_label=(str)
|
|
self.description = str
|
|
end
|
|
|
|
def to_param
|
|
Parameterizable.parameterize("#{id}-#{title}")
|
|
end
|
|
|
|
def release
|
|
"#{major}#{('.' + minor.to_s) if minor.present?}"
|
|
end
|
|
|
|
def fullname
|
|
"#{name} #{release}"
|
|
end
|
|
|
|
def to_s
|
|
fullname
|
|
end
|
|
|
|
def self.find_by_to_label(str)
|
|
os = find_by_description(str.to_s)
|
|
return os if os
|
|
a = str.split(" ")
|
|
b = a[1].split('.') if a[1]
|
|
cond = {:name => a[0]}
|
|
cond[:major] = b[0] if b && b[0]
|
|
cond[:minor] = b[1] if b && b[1]
|
|
find_by(cond)
|
|
end
|
|
|
|
# Implemented only in the OSs subclasses where it makes sense
|
|
def available_loaders
|
|
["None", "PXELinux BIOS"]
|
|
end
|
|
|
|
# The DHCP record type to use, can be overriden by OSs subclasses
|
|
def dhcp_record_type
|
|
Net::DHCP::Record
|
|
end
|
|
|
|
# sets the prefix for the tfp files based on medium unique identifier
|
|
def pxe_prefix(medium_provider)
|
|
unless medium_provider.is_a? MediumProviders::Provider
|
|
raise Foreman::Exception.new(N_('Please provide a medium provider. It can be found as @medium_provider in templates, or Foreman::Plugin.medium_providers_registry.find_provider(host)'))
|
|
end
|
|
"boot/#{medium_provider.unique_id}"
|
|
end
|
|
|
|
def pxe_files(medium_provider)
|
|
unless medium_provider.is_a? MediumProviders::Provider
|
|
raise Foreman::Exception.new(N_('Please provide a medium provider. It can be found as @medium_provider in templates, or Foreman::Plugin.medium_providers_registry.find_provider(host)'))
|
|
end
|
|
boot_files_uri(medium_provider).collect do |img|
|
|
{ pxe_prefix(medium_provider).to_sym => img.to_s}
|
|
end
|
|
end
|
|
|
|
def pxedir(medium_provider = nil)
|
|
""
|
|
end
|
|
|
|
apipie :method, 'Returns path to the kernel to be installed with prefix based on given medium provider' do
|
|
required :medium_provider, 'MediumProviders::Provider', 'Medium provider responsible to provide location of installation medium for a given entity (host or host group)'
|
|
returns String, 'Path to the kernel to be installed'
|
|
end
|
|
def kernel(medium_provider)
|
|
bootfile(medium_provider, :kernel)
|
|
end
|
|
|
|
apipie :method, 'Returns path to the initial RAM disk with prefix based on given medium provider' do
|
|
required :medium_provider, 'MediumProviders::Provider', 'Medium provider responsible to provide location of installation medium for a given entity (host or host group)'
|
|
returns String, 'Path to the initial RAM disk'
|
|
end
|
|
def initrd(medium_provider)
|
|
bootfile(medium_provider, :initrd)
|
|
end
|
|
|
|
apipie :method, 'Returns path to various different bootfiles based on given medium provider and type' do
|
|
required :medium_provider, 'MediumProviders::Provider', 'Medium provider responsible to provide location of installation medium for a given entity (host or host group)'
|
|
required :type, String, 'Bootfile type (like "kernel", "initrd", "bcd", "bootsdi", "bootwim", "xen")'
|
|
returns String, 'Path to the specific bootfile'
|
|
end
|
|
def bootfile(medium_provider, type)
|
|
unless medium_provider.is_a? MediumProviders::Provider
|
|
raise Foreman::Exception.new(N_('Please provide a medium provider. It can be found as @medium_provider in templates, or Foreman::Plugin.medium_providers_registry.find_provider(host)'))
|
|
end
|
|
pxe_prefix(medium_provider) + "-" + pxe_file_names(medium_provider)[type.to_sym]
|
|
end
|
|
|
|
# Does this OS family support a build variant that is constructed from a prebuilt archive
|
|
def supports_image
|
|
false
|
|
end
|
|
|
|
# Compatible kinds for this OS sorted by preferrence
|
|
def template_kinds
|
|
['PXELinux', 'PXEGrub2', 'PXEGrub', 'iPXE']
|
|
end
|
|
|
|
# iPXE templates should not get transfered to tftp
|
|
def template_kinds_for_tftp
|
|
template_kinds.select { |kind| kind != 'iPXE' }
|
|
end
|
|
|
|
def boot_filename(host = nil)
|
|
return default_boot_filename if host.nil? || host.pxe_loader.nil?
|
|
return host.foreman_url('iPXE') if host.pxe_loader == 'iPXE Embedded'
|
|
architecture = host.arch.nil? ? '' : host.arch.bootfilename_efi
|
|
if host.subnet&.httpboot? && host.pxe_loader =~ /UEFI HTTP/
|
|
if host.pxe_loader =~ /HTTPS/
|
|
port = host.subnet.httpboot.httpboot_https_port!
|
|
else
|
|
port = host.subnet.httpboot.httpboot_http_port!
|
|
end
|
|
hostname = URI.parse(host.subnet.httpboot.url).hostname
|
|
self.class.all_loaders_map(architecture, "#{hostname}:#{port}")[host.pxe_loader]
|
|
else
|
|
raise(::Foreman::Exception.new(N_("HTTP UEFI boot requires proxy with httpboot feature"))) if host.pxe_loader =~ /UEFI HTTP/
|
|
self.class.all_loaders_map(architecture)[host.pxe_loader]
|
|
end
|
|
end
|
|
|
|
# Does this OS family use release_name in its naming scheme
|
|
def use_release_name?
|
|
return false unless family
|
|
return becomes(family.constantize).use_release_name? unless self.class == family.constantize
|
|
false
|
|
end
|
|
|
|
# Helper text shown next to major version (do not use i18n)
|
|
def major_version_help
|
|
'7'
|
|
end
|
|
|
|
# Helper text shown next to minor version (do not use i18n)
|
|
def minor_version_help
|
|
'e.g. 0 or 6.1810 (CentOS scheme)'
|
|
end
|
|
|
|
# Helper text shown next to release name (do not use i18n)
|
|
def release_name_help
|
|
'karmic, lucid, hw0910...'
|
|
end
|
|
|
|
def image_extension
|
|
raise ::Foreman::Exception.new(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 self.require_nfs_access_to_medium
|
|
false
|
|
end
|
|
|
|
# Pretty method for displaying the Family name
|
|
def display_family
|
|
"Unknown"
|
|
end
|
|
|
|
def shorten_description(description)
|
|
# This method should be overridden in the OS subclass
|
|
# to handle shortening the specific formats of lsbdistdescription
|
|
# returned by Facter on that OS
|
|
description
|
|
end
|
|
|
|
def self.deduce_family(name)
|
|
families.find do |f|
|
|
name =~ FAMILIES[f]
|
|
end
|
|
end
|
|
|
|
def deduce_family
|
|
family || self.class.deduce_family(name)
|
|
end
|
|
|
|
apipie :method, 'Returns an array of boot file sources URIs' do
|
|
required :medium_provider, 'MediumProviders::Provider', 'Medium provider responsible to provide location of installation medium for a given entity (host or host group)'
|
|
block schema: '{ |vars| }', desc: 'Allows to adjust medium variables within the block'
|
|
returns Array, desc: 'Array of boot file sources URIs'
|
|
end
|
|
def boot_files_uri(medium_provider, &block)
|
|
boot_file_sources(medium_provider, &block).values
|
|
end
|
|
|
|
def url_for_boot(medium_provider, file, &block)
|
|
boot_file_sources(medium_provider, &block)[file]
|
|
end
|
|
|
|
def pxe_file_names(medium_provider)
|
|
raise(::Foreman::Exception.new(N_("Operating System has no family, can't load PXE files"))) unless family
|
|
family.constantize::PXEFILES
|
|
end
|
|
|
|
def boot_file_sources(medium_provider, &block)
|
|
@boot_file_sources ||= pxe_file_names(medium_provider).transform_values do |img|
|
|
img = medium_provider.interpolate_vars(img)
|
|
"#{medium_provider.medium_uri(pxedir(medium_provider), &block)}/#{img}"
|
|
end
|
|
end
|
|
|
|
def pxe_kernel_options(params)
|
|
options = []
|
|
options << params['kernelcmd'] if params['kernelcmd']
|
|
options
|
|
end
|
|
|
|
apipie :method, 'Returns medium URI for given medium provider' do
|
|
required :medium_provider, 'MediumProviders::Provider', desc: 'Medium provider'
|
|
returns String, desc: 'Medium URI of given medium provider'
|
|
end
|
|
def mediumpath(medium_provider)
|
|
medium_provider.medium_uri.to_s
|
|
end
|
|
|
|
def has_default_template?(template_kind)
|
|
os_default_templates.find_by(template_kind: template_kind) || false
|
|
end
|
|
|
|
private
|
|
|
|
def set_family
|
|
self.family ||= deduce_family
|
|
end
|
|
|
|
def set_title
|
|
self.title = to_label.to_s[0..254]
|
|
end
|
|
|
|
def stringify_major_and_minor
|
|
# Cast major and minor to strings.
|
|
# Need to ensure type when using major and minor as scopes for name uniqueness.
|
|
self.major = major.to_s
|
|
self.minor = minor.to_s
|
|
end
|
|
|
|
def downcase_release_name
|
|
self.release_name = release_name.downcase if release_name.present?
|
|
end
|
|
|
|
def reject_empty_provisioning_template(attributes)
|
|
template_exists = attributes[:id].present?
|
|
provisioning_template_id_empty = attributes[:provisioning_template_id].blank?
|
|
attributes[:_destroy] = 1 if template_exists && provisioning_template_id_empty
|
|
(!template_exists && provisioning_template_id_empty)
|
|
end
|
|
|
|
def assign_init_config_template
|
|
template_name = Setting[:default_host_init_config_template]
|
|
template_kind = TemplateKind.unscoped.find_by(name: 'host_init_config')
|
|
template = ProvisioningTemplate.unscoped.find_by(name: template_name, template_kind: template_kind)
|
|
return unless template
|
|
|
|
template.operatingsystems << self
|
|
OsDefaultTemplate.create(template_kind: template_kind, provisioning_template: template, operatingsystem: self)
|
|
end
|
|
end
|
