foreman_discovery 1.0.0.rc1

data/test/foreman_app/app/models/host/hostmix.rb

@@ -0,0 +1,13 @@
+module Host
+  module Hostmix
+
+      def has_many_hosts(options = {})
+        has_many :hosts, {:class_name => "Host::Managed"}.merge(options)
+      end
+
+      def belongs_to_host(options = {})
+        belongs_to :host, {:class_name => "Host::Managed", :foreign_key => :host_id}.merge(options)
+      end
+
+  end
+end

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

@@ -0,0 +1,854 @@
+class Host::Managed < Host::Base
+  include Authorization
+  include ReportCommon
+  include Hostext::Search
+
+  has_many :host_classes, :dependent => :destroy, :foreign_key => :host_id
+  has_many :puppetclasses, :through => :host_classes
+  belongs_to :hostgroup
+  has_many :reports, :dependent => :destroy, :foreign_key => :host_id
+  has_many :host_parameters, :dependent => :destroy, :foreign_key => :reference_id
+  has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "HostParameter"
+  accepts_nested_attributes_for :host_parameters, :reject_if => lambda { |a| a[:value].blank? }, :allow_destroy => true
+  has_many :interfaces, :dependent => :destroy, :inverse_of => :host, :class_name => 'Nic::Base', :foreign_key => :host_id
+  accepts_nested_attributes_for :interfaces, :reject_if => lambda { |a| a[:mac].blank? }, :allow_destroy => true
+  belongs_to :owner, :polymorphic => true
+  belongs_to :compute_resource
+  belongs_to :image
+
+  belongs_to :location
+  belongs_to :organization
+
+  has_one :token, :foreign_key => :host_id, :dependent => :destroy, :conditions => Proc.new {"expires >= '#{Time.now.utc.to_s(:db)}'"}
+
+  has_many :lookup_values, :finder_sql => Proc.new { normalize_hostname; %Q{ SELECT lookup_values.* FROM lookup_values WHERE (lookup_values.match = 'fqdn=#{fqdn}') } }, :dependent => :destroy
+  # See "def lookup_values_attributes=" under, for the implementation of accepts_nested_attributes_for :lookup_values
+  accepts_nested_attributes_for :lookup_values
+
+  # Define custom hook that can be called in model by magic methods (before, after, around)
+  define_model_callbacks :build, :only => :after
+  define_model_callbacks :provision, :only => :before
+
+  # Custom hooks will be executed after_commit
+  after_commit :build_hooks
+
+  def build_hooks
+    return unless respond_to?(:old) && old && (build? != old.build?)
+    if build?
+      run_callbacks :build do
+        logger.debug { "custom hook after_build on #{name} will be executed if defined." }
+      end
+    else
+      run_callbacks :provision do
+        logger.debug { "custom hook before_provision on #{name} will be executed if defined." }
+      end
+    end
+  end
+
+  include HostCommon
+
+  class Jail < ::Safemode::Jail
+    allow :name, :diskLayout, :puppetmaster, :puppet_ca_server, :operatingsystem, :os, :environment, :ptable, :hostgroup, :location,
+      :organization, :url_for_boot, :params, :info, :hostgroup, :compute_resource, :domain, :ip, :mac, :shortname, :architecture,
+      :model, :certname, :capabilities, :provider, :subnet, :token, :location, :organization
+  end
+
+  attr_reader :cached_host_params
+
+  default_scope lambda {
+      org = Organization.current
+      loc = Location.current
+      conditions = {}
+      conditions[:organization_id] = Array.wrap(org).map(&:id) if org
+      conditions[:location_id]     = Array.wrap(loc).map(&:id) if loc
+      where(conditions)
+    }
+
+  scope :recent,      lambda { |*args| {:conditions => ["last_report > ?", (args.first || (Setting[:puppet_interval] + 5).minutes.ago)]} }
+  scope :out_of_sync, lambda { |*args| {:conditions => ["last_report < ? and enabled != ?", (args.first || (Setting[:puppet_interval] + 5).minutes.ago), false]} }
+
+  scope :with_os, lambda { where('hosts.operatingsystem_id IS NOT NULL') }
+  scope :no_location, lambda { where(:location_id => nil) }
+  scope :no_organization, lambda { where(:organization_id => nil) }
+
+  scope :with_error, { :conditions => "(puppet_status > 0) and
+   ( ((puppet_status >> #{BIT_NUM*METRIC.index("failed")} & #{MAX}) != 0) or
+    ((puppet_status >> #{BIT_NUM*METRIC.index("failed_restarts")} & #{MAX}) != 0) )"
+  }
+
+  scope :without_error, { :conditions =>
+    "((puppet_status >> #{BIT_NUM*METRIC.index("failed")} & #{MAX}) = 0) and
+     ((puppet_status >> #{BIT_NUM*METRIC.index("failed_restarts")} & #{MAX}) = 0)"
+  }
+
+  scope :with_changes, { :conditions => "(puppet_status > 0) and
+    ( ((puppet_status >> #{BIT_NUM*METRIC.index("applied")} & #{MAX}) != 0) or
+    ((puppet_status >> #{BIT_NUM*METRIC.index("restarted")} & #{MAX}) != 0) )"
+  }
+
+  scope :without_changes, { :conditions =>
+    "((puppet_status >> #{BIT_NUM*METRIC.index("applied")} & #{MAX}) = 0) and
+     ((puppet_status >> #{BIT_NUM*METRIC.index("restarted")} & #{MAX}) = 0)"
+  }
+
+  scope :with_pending_changes,    { :conditions =>
+    "(puppet_status > 0) and ((puppet_status >> #{BIT_NUM*METRIC.index("pending")} & #{MAX}) != 0)" }
+  scope :without_pending_changes, { :conditions =>
+    "((puppet_status >> #{BIT_NUM*METRIC.index("pending")} & #{MAX}) = 0)" }
+
+  scope :successful, lambda { without_changes.without_error.without_pending_changes}
+
+  scope :alerts_disabled, {:conditions => ["enabled = ?", false] }
+
+  scope :alerts_enabled, {:conditions => ["enabled = ?", true] }
+
+  scope :my_hosts, lambda {
+    user                 = User.current
+    return { :conditions => "" } if user.admin? # Admin can see all hosts
+
+    owner_conditions             = sanitize_sql_for_conditions(["((hosts.owner_id in (?) AND hosts.owner_type = 'Usergroup') OR (hosts.owner_id = ? AND hosts.owner_type = 'User'))", user.my_usergroups.map(&:id), user.id])
+    domain_conditions            = sanitize_sql_for_conditions([" (hosts.domain_id in (?))",dms = (user.domain_ids)])
+    compute_resource_conditions  = sanitize_sql_for_conditions([" (hosts.compute_resource_id in (?))",(crs = user.compute_resource_ids)])
+    hostgroup_conditions         = sanitize_sql_for_conditions([" (hosts.hostgroup_id in (?))",(hgs = user.hostgroup_ids)])
+    organization_conditions      = sanitize_sql_for_conditions([" (hosts.organization_id in (?))",orgs = (user.organization_ids)])
+    location_conditions          = sanitize_sql_for_conditions([" (hosts.location_id in (?))",locs = (user.location_ids)])
+
+    fact_conditions = ""
+    for user_fact in (ufs = user.user_facts)
+      fact_conditions += sanitize_sql_for_conditions ["(hosts.id = fact_values.host_id and fact_values.fact_name_id = ? and fact_values.value #{user_fact.operator} ?)", user_fact.fact_name_id, user_fact.criteria]
+      fact_conditions = user_fact.andor == "and" ? "(#{fact_conditions}) and " : "#{fact_conditions} or  "
+    end
+    if (match = fact_conditions.match(/^(.*).....$/))
+      fact_conditions = "(#{match[1]})"
+    end
+
+    conditions = ""
+    if user.filtering?
+      conditions  = "#{owner_conditions}"                                                                                                                                 if     user.filter_on_owner
+      (conditions = (user.domains_andor           == "and") ? "(#{conditions}) and #{domain_conditions} "           : "#{conditions} or #{domain_conditions} ")           unless dms.empty?
+      (conditions = (user.compute_resources_andor == "and") ? "(#{conditions}) and #{compute_resource_conditions} " : "#{conditions} or #{compute_resource_conditions} ") unless crs.empty?
+      (conditions = (user.hostgroups_andor        == "and") ? "(#{conditions}) and #{hostgroup_conditions} "        : "#{conditions} or #{hostgroup_conditions} ")        unless hgs.empty?
+      (conditions = (user.facts_andor             == "and") ? "(#{conditions}) and #{fact_conditions} "             : "#{conditions} or #{fact_conditions} ")             unless ufs.empty?
+      (conditions = (user.organizations_andor     == "and") ? "(#{conditions}) and #{organization_conditions} "     : "#{conditions} or #{organization_conditions} ")     unless orgs.empty?
+      (conditions = (user.locations_andor         == "and") ? "(#{conditions}) and #{location_conditions} "         : "#{conditions} or #{location_conditions} ")         unless locs.empty?
+      conditions.sub!(/\s*\(\)\s*/, "")
+      conditions.sub!(/^(?:\(\))?\s?(?:and|or)\s*/, "")
+      conditions.sub!(/\(\s*(?:or|and)\s*\(/, "((")
+    end
+    {:conditions => conditions}
+  }
+
+  scope :completer_scope, lambda { my_hosts }
+
+  scope :run_distribution, lambda { |fromtime,totime|
+    if fromtime.nil? or totime.nil?
+      raise ::Foreman.Exception.new(N_("invalid time range"))
+    else
+      { :joins      => "INNER JOIN reports ON reports.host_id = hosts.id",
+        :conditions => ["reports.reported_at BETWEEN ? AND ?", fromtime, totime] }
+    end
+  }
+
+  scope :for_token, lambda { |token| joins(:token).where(:tokens => { :value => token }).select('hosts.*') }
+
+  # audit the changes to this model
+  audited :except => [:last_report, :puppet_status, :last_compile]
+  has_associated_audits
+
+  # some shortcuts
+  alias_attribute :os, :operatingsystem
+  alias_attribute :arch, :architecture
+  alias_attribute :fqdn, :name
+
+  validates_presence_of :environment_id
+
+  if SETTINGS[:unattended]
+    # handles all orchestration of smart proxies.
+    include Foreman::Renderer
+    include Orchestration
+    include Orchestration::DHCP
+    include Orchestration::DNS
+    include Orchestration::Compute
+    include Orchestration::TFTP
+    include Orchestration::Puppetca
+    include Orchestration::SSHProvision
+    include HostTemplateHelpers
+
+    validates_uniqueness_of  :ip, :if => Proc.new {|host| host.require_ip_validation?}
+    validates_uniqueness_of  :mac, :unless => Proc.new { |host| host.compute? or !host.managed }
+    validates_presence_of    :architecture_id, :operatingsystem_id, :if => Proc.new {|host| host.managed}
+    validates_presence_of    :domain_id, :if => Proc.new {|host| host.managed}
+    validates_presence_of    :mac, :unless => Proc.new { |host| host.compute? or !host.managed  }
+
+    validates_length_of      :root_pass, :minimum => 8, :too_short => _('should be 8 characters or more')
+    validates_format_of      :mac, :with => Net::Validations::MAC_REGEXP, :unless => Proc.new { |host| host.compute? or !host.managed }
+    validates_format_of      :ip,        :with => Net::Validations::IP_REGEXP, :if => Proc.new { |host| host.require_ip_validation? }
+    validates_presence_of    :ptable_id, :message => N_("cant be blank unless a custom partition has been defined"),
+      :if => Proc.new { |host| host.managed and host.disk.empty? and not defined?(Rake) and capabilities.include?(:build) }
+    validates_format_of      :serial,    :with => /[01],\d{3,}n\d/, :message => N_("should follow this format: 0,9600n8"), :allow_blank => true, :allow_nil => true
+
+    validates_presence_of :puppet_proxy_id, :if => Proc.new {|h| h.managed? } if SETTINGS[:unattended]
+  end
+
+  before_validation :set_hostgroup_defaults, :set_ip_address, :set_default_user, :normalize_addresses, :normalize_hostname, :force_lookup_value_matcher
+  after_validation :ensure_associations
+  before_validation :set_certname, :if => Proc.new {|h| h.managed? and Setting[:use_uuid_for_certificates] } if SETTINGS[:unattended]
+
+  # Replacement of accepts_nested_attributes_for :lookup_values,
+  # to work around the lack of `host_id` column in lookup_values.
+  def lookup_values_attributes= lookup_values_attributes
+    lookup_values_attributes.each_value do |attribute|
+      attr = attribute.dup
+      if attr.has_key? :id
+        lookup_value = lookup_values.find attr.delete(:id)
+        if lookup_value
+          mark_for_destruction = ActiveRecord::ConnectionAdapters::Column.value_to_boolean attr.delete(:_destroy)
+          lookup_value.attributes = attr
+          mark_for_destruction ? lookup_values.delete(lookup_value) : lookup_value.save!
+        end
+      elsif !ActiveRecord::ConnectionAdapters::Column.value_to_boolean attr.delete(:_destroy)
+        lookup_values.build(attr)
+      end
+    end
+  end
+
+  def <=>(other)
+    self.name <=> other.name
+  end
+
+  def shortname
+    domain.nil? ? name : name.chomp("." + domain.name)
+  end
+
+  # method to return the correct owner list for host edit owner select dropbox
+  def is_owned_by
+    owner.id_and_type if owner
+  end
+
+  def self.model_name
+    ActiveModel::Name.new(Host)
+  end
+
+  # virtual attributes which sets the owner based on the user selection
+  # supports a simple user, or a usergroup
+  # selection parameter is expected to be an ActiveRecord id_and_type method (see Foreman's AR extentions).
+  def is_owned_by=(selection)
+    oid = User.find(selection.to_i) if selection =~ (/-Users$/)
+    oid = Usergroup.find(selection.to_i) if selection =~ (/-Usergroups$/)
+    self.owner = oid
+  end
+
+  def clearReports
+    # Remove any reports that may be held against this host
+    Report.delete_all("host_id = #{id}")
+  end
+
+  def clearFacts
+    FactValue.delete_all("host_id = #{id}")
+  end
+
+  def set_token
+    return unless Setting[:token_duration] != 0
+    self.create_token(:value => Foreman.uuid,
+                      :expires => Time.now.utc + Setting[:token_duration].minutes)
+  end
+
+  def expire_tokens
+    # this clean up other hosts as well, but reduce the need for another task to cleanup tokens.
+    Token.delete_all(["expires < ? or host_id = ?", Time.now.utc.to_s(:db), id])
+  end
+
+  # Called from the host build post install process to indicate that the base build has completed
+  # Build is cleared and the boot link and autosign entries are removed
+  # A site specific build script is called at this stage that can do site specific tasks
+  def built(installed = true)
+
+    # delete all expired tokens
+    self.build        = false
+    self.installed_at = Time.now.utc if installed
+    self.save
+  rescue => e
+    logger.warn "Failed to set Build on #{self}: #{e}"
+    false
+  end
+
+  #retuns fqdn of host puppetmaster
+  def pm_fqdn
+    puppetmaster == "puppet" ? "puppet.#{domain.name}" : "#{puppetmaster}"
+  end
+
+  # Cleans Certificate and enable Autosign
+  # Called after a host is given their provisioning template
+  # Returns : Boolean status of the operation
+  def handle_ca
+    return true if Rails.env == "test"
+    return true unless Setting[:manage_puppetca]
+    if puppetca?
+      respond_to?(:initialize_puppetca) && initialize_puppetca && delCertificate && setAutosign
+    end
+  end
+
+  # returns the host correct disk layout, custom or common
+  def diskLayout
+    @host = self
+    pxe_render((disk.empty? ? ptable.layout : disk).gsub("\r",""))
+  end
+
+  # returns a configuration template (such as kickstart) to a given host
+  def configTemplate opts = {}
+    opts[:kind]               ||= "provision"
+    opts[:operatingsystem_id] ||= operatingsystem_id
+    opts[:hostgroup_id]       ||= hostgroup_id
+    opts[:environment_id]     ||= environment_id
+
+    ConfigTemplate.find_template opts
+  end
+
+  # reports methods
+
+  def error_count
+    %w[failed failed_restarts].sum {|f| status f}
+  end
+
+  def no_report
+    last_report.nil? or last_report < Time.now - (Setting[:puppet_interval] + 3).minutes and enabled?
+  end
+
+  def disabled?
+    not enabled?
+  end
+
+  # returns the list of puppetclasses a host is in.
+  def puppetclasses_names
+    all_puppetclasses.collect {|c| c.name}
+  end
+
+  def all_puppetclasses
+    hostgroup.nil? ? puppetclasses : (hostgroup.classes + puppetclasses).uniq
+  end
+
+  # provide information about each node, mainly used for puppet external nodes
+  # TODO: remove hard coded default parameters into some selectable values in the database.
+  def info
+    # Static parameters
+    param = {}
+    # maybe these should be moved to the common parameters, leaving them in for now
+    param["puppetmaster"] = puppetmaster
+    param["domainname"]   = domain.fullname unless domain.nil? or domain.fullname.nil?
+    param["hostgroup"]    = hostgroup.to_label unless hostgroup.nil?
+    if SETTINGS[:locations_enabled]
+      param["location"] = location.name unless location.blank?
+    end
+    if SETTINGS[:organizations_enabled]
+      param["organization"] = organization.name unless organization.blank?
+    end
+    if SETTINGS[:unattended]
+      param["root_pw"]      = root_pass
+      param["puppet_ca"]    = puppet_ca_server if puppetca?
+    end
+    param["comment"]      = comment unless comment.blank?
+    param["foreman_env"]  = environment.to_s unless environment.nil? or environment.name.nil?
+    if SETTINGS[:login] and owner
+      param["owner_name"]  = owner.name
+      param["owner_email"] = owner.is_a?(User) ? owner.mail : owner.users.map(&:mail)
+    end
+
+    if Setting[:ignore_puppet_facts_for_provisioning]
+      param["ip"]  = ip
+      param["mac"] = mac
+    end
+    param.update self.params
+
+    classes = if Setting[:Parametrized_Classes_in_ENC] && Setting[:Enable_Smart_Variables_in_ENC]
+                lookup_keys_class_params
+              else
+                self.puppetclasses_names
+              end
+
+    info_hash = {}
+    info_hash['classes'] = classes
+    info_hash['parameters'] = param
+    info_hash['environment'] = param["foreman_env"] if Setting["enc_environment"]
+
+    info_hash
+  end
+
+  def params
+    host_params.update(lookup_keys_params)
+  end
+  def clear_host_parameters_cache!
+    @cached_host_params = nil
+  end
+
+  def host_inherited_params include_source = false
+    hp = {}
+    # read common parameters
+    CommonParameter.all.each {|p| hp.update Hash[p.name => include_source ? {:value => p.value, :source => :common} : p.value] }
+    # read domain parameters
+    domain.domain_parameters.each {|p| hp.update Hash[p.name => include_source ? {:value => p.value, :source => :domain} : p.value] } unless domain.nil?
+    # read OS parameters
+    operatingsystem.os_parameters.each {|p| hp.update Hash[p.name => include_source ? {:value => p.value, :source => :os} : p.value] } unless operatingsystem.nil?
+    # read group parameters only if a host belongs to a group
+    hp.update hostgroup.parameters(include_source) unless hostgroup.nil?
+    hp
+  end
+
+  def host_params
+    return cached_host_params unless cached_host_params.blank?
+    hp = host_inherited_params
+    # and now read host parameters, override if required
+    host_parameters.each {|p| hp.update Hash[p.name => p.value] }
+    @cached_host_params = hp
+  end
+
+  def self.importHostAndFacts yaml
+    facts = YAML::load yaml
+    case facts
+      when Puppet::Node::Facts
+        certname = facts.values["certname"]
+        name     = facts.values["fqdn"].downcase
+        values   = facts.values
+      when Hash
+        certname = facts["certname"]
+        name     = facts["fqdn"].downcase
+        values   = facts
+        return raise(::Foreman::Exception.new(N_("invalid facts hash"))) unless name and values
+      else
+        return raise(::Foreman::Exception.new(N_("Invalid Facts, much be a Puppet::Node::Facts or a Hash")))
+    end
+
+    if name == certname or certname.nil?
+      h = Host.find_by_name name
+    else
+      h = Host.find_by_certname certname
+      h ||= Host.find_by_name name
+    end
+    h ||= Host.new :name => name
+
+    h.save(:validate => false) if h.new_record?
+    h.importFacts(name, values)
+  end
+
+  def attributes_to_import_from_facts
+    attrs = []
+    attrs = [:mac, :ip] unless managed? and Setting[:ignore_puppet_facts_for_provisioning]
+    super + [:domain, :architecture, :operatingsystem, :model, :certname] + attrs
+  end
+
+  def populateFieldsFromFacts facts = self.facts_hash
+    importer = super
+    normalize_addresses
+    if Setting[:update_environment_from_facts]
+      set_non_empty_values importer, [:environment]
+    else
+      self.environment ||= importer.environment unless importer.environment.blank?
+    end
+
+    self.save(:validate => false)
+  end
+
+  # Called by build link in the list
+  # Build is set
+  # The boot link and autosign entry are created
+  # Any existing puppet certificates are deleted
+  # Any facts are discarded
+  def setBuild
+    clearFacts
+    clearReports
+
+    self.build = true
+    self.save
+    errors.empty?
+  end
+
+  # this method accepts a puppets external node yaml output and generate a node in our setup
+  # it is assumed that you already have the node (e.g. imported by one of the rack tasks)
+  def importNode nodeinfo
+    myklasses= []
+    # puppet classes
+    nodeinfo["classes"].each do |klass|
+      if (pc = Puppetclass.find_by_name(klass))
+        myklasses << pc
+      else
+        error = _("Failed to import %{klass} for %{name}: doesn't exists in our database - ignoring") % { :klass => klass, :name => name }
+        logger.warn error
+        $stdout.puts error
+      end
+      self.puppetclasses = myklasses
+    end
+
+    # parameters are a bit more tricky, as some classifiers provide the facts as parameters as well
+    # not sure what is puppet priority about it, but we ignore it if has a fact with the same name.
+    # additionally, we don't import any non strings values, as puppet don't know what to do with those as well.
+
+    myparams = self.info["parameters"]
+    nodeinfo["parameters"].each_pair do |param,value|
+      next if fact_names.exists? :name => param
+      next unless value.is_a?(String)
+
+      # we already have this parameter
+      next if myparams.has_key?(param) and myparams[param] == value
+
+      unless (hp = self.host_parameters.create(:name => param, :value => value))
+        logger.warn "Failed to import #{param}/#{value} for #{name}: #{hp.errors.full_messages.join(", ")}"
+        $stdout.puts $!
+      end
+    end
+
+    self.save
+  end
+
+  # counts each association of a given host
+  # e.g. how many hosts belongs to each os
+  # returns sorted hash
+  def self.count_distribution assocication
+    output = []
+    count(:group => assocication).each do |k,v|
+      begin
+        output << {:label => k.to_label, :data => v }  unless v == 0
+      rescue
+        logger.info "skipped #{k} as it has has no label"
+      end
+    end
+    output
+  end
+
+  # counts each association of a given host for HABTM relationships
+  # TODO: Merge these two into one method
+  # e.g. how many hosts belongs to each os
+  # returns sorted hash
+  def self.count_habtm association
+    counter = Host::Managed.joins(association.tableize.to_sym).group("#{association.tableize.to_sym}.id").count
+    #Puppetclass.find(counter.keys.compact)...
+    association.camelize.constantize.find(counter.keys.compact).map {|i| {:label=>i.to_label, :data =>counter[i.id]}}
+  end
+
+  def classes_from_storeconfigs
+    klasses = resources.select(:title).where(:restype => "Class").where("title <> ? AND title <> ?", "main", "Settings").order(:title)
+    klasses.map!(&:title).delete(:main)
+    klasses
+  end
+
+  def can_be_built?
+    managed? and SETTINGS[:unattended] and capabilities.include?(:build) ? build == false : false
+  end
+
+  def enforce_permissions operation
+    if operation == "edit" and new_record?
+      return true # We get called again with the operation being set to create
+    end
+    current = User.current
+    if (operation == "edit") or operation == "destroy"
+      if current.allowed_to?("#{operation}_hosts".to_sym)
+        return true if Host.my_hosts.include? self
+      end
+    else # create
+      if current.allowed_to?(:create_hosts)
+        # We are unconstrained
+        return true if current.domains.empty? and current.hostgroups.empty?
+        # We are constrained and the constraint is matched
+        return true if (!current.domains.empty?    and current.domains.include?(domain)) or
+        (!current.hostgroups.empty? and current.hostgroups.include?(hostgroup))
+      end
+    end
+    errors.add(:base, _("You do not have permission to %s this host") % operation)
+    false
+  end
+
+  def jumpstart?
+    operatingsystem.family == "Solaris" and architecture.name =~/Sparc/i rescue false
+  end
+
+  def set_hostgroup_defaults
+    return unless hostgroup
+    assign_hostgroup_attributes(%w{environment domain puppet_proxy puppet_ca_proxy})
+    if SETTINGS[:unattended] and (new_record? or managed?)
+      assign_hostgroup_attributes(%w{operatingsystem architecture})
+      assign_hostgroup_attributes(%w{medium ptable subnet}) if capabilities.include?(:build)
+    end
+  end
+
+  def set_ip_address
+    self.ip ||= subnet.unused_ip if subnet and SETTINGS[:unattended] and (new_record? or managed?)
+  end
+
+  # returns a rundeck output
+  def rundeck
+    rdecktags = puppetclasses_names.map{|k| "class=#{k}"}
+    unless self.params["rundeckfacts"].empty?
+      rdecktags += self.params["rundeckfacts"].split(",").map{|rdf| "#{rdf}=#{fact(rdf)[0].value}"}
+    end
+    { name => { "description" => comment, "hostname" => name, "nodename" => name,
+      "osArch" => arch.name, "osFamily" => os.family, "osName" => os.name,
+      "osVersion" => os.release, "tags" => rdecktags, "username" => self.params["rundeckuser"] || "root" }
+    }
+  rescue => e
+    logger.warn "Failed to fetch rundeck info for #{to_s}: #{e}"
+    {}
+  end
+
+  def puppetrun!
+    unless puppet_proxy.present?
+      errors.add(:base, _("no puppet proxy defined - cant continue"))
+      logger.warn "unable to execute puppet run, no puppet proxies defined"
+      return false
+    end
+    ProxyAPI::Puppet.new({:url => puppet_proxy.url}).run fqdn
+  rescue => e
+    errors.add(:base, _("failed to execute puppetrun: %s") % e)
+    false
+  end
+
+  def overwrite?
+    @overwrite ||= false
+  end
+
+  # We have to coerce the value back to boolean. It is not done for us by the framework.
+  def overwrite=(value)
+    @overwrite = value == "true"
+  end
+
+  def require_ip_validation?
+    managed? and !compute? or (compute? and !compute_resource.provided_attributes.keys.include?(:ip))
+  end
+
+  # if certname does not exist, use hostname instead
+  def certname
+    read_attribute(:certname) || name
+  end
+
+  def progress_report_id
+    @progress_report_id ||= Foreman.uuid
+  end
+
+  def progress_report_id=(value)
+    @progress_report_id = value
+  end
+
+  def capabilities
+    compute_resource_id ? compute_resource.capabilities : [:build]
+  end
+
+  def provider
+    if compute_resource_id
+      compute_resource.provider_friendly_name
+    else
+      "BareMetal"
+    end
+  end
+
+  # no need to store anything in the db if the password is our default
+  def root_pass
+    read_attribute(:root_pass) || hostgroup.try(:root_pass) || Setting[:root_pass]
+  end
+
+  def clone
+    new = super
+    new.puppetclasses = puppetclasses
+    # Clone any parameters as well
+    host_parameters.each{|param| new.host_parameters << HostParameter.new(:name => param.name, :value => param.value, :nested => true)}
+    interfaces.each {|int| new.interfaces << int.clone }
+    # clear up the system specific attributes
+    [:name, :mac, :ip, :uuid, :certname, :last_report].each do |attr|
+      new.send "#{attr}=", nil
+    end
+    new.puppet_status = 0
+    new
+  end
+
+  def sp_ip
+    bmc_nic.try(:ip)
+  end
+
+  def sp_mac
+    bmc_nic.try(:mac)
+  end
+
+  def sp_subnet_id
+    bmc_nic.try(:subnet_id)
+  end
+
+  def sp_subnet
+    bmc_nic.try(:subnet)
+  end
+
+  def sp_name
+    bmc_nic.try(:name)
+  end
+
+  def host_status
+    if build
+      N_("Pending Installation")
+    elsif respond_to?(:enabled) && !enabled
+      N_("Alerts disabled")
+    elsif respond_to?(:last_report) && last_report.nil?
+      N_("No reports")
+    elsif no_report
+      N_("Out of sync")
+    elsif error?
+      N_("Error")
+    elsif changes?
+      N_("Active")
+    elsif pending?
+      N_("Pending")
+    else
+      N_("No changes")
+    end
+  end
+
+  def smart_proxies
+    SmartProxy.where(:id => smart_proxy_ids)
+  end
+
+  def smart_proxy_ids
+    ids = []
+    [subnet, hostgroup.try(:subnet)].compact.each do |s|
+      ids << s.dhcp_id
+      ids << s.tftp_id
+      ids << s.dns_id
+    end
+
+    [domain, hostgroup.try(:domain)].compact.each do |d|
+      ids << d.dns_id
+    end
+
+    [puppet_proxy_id, puppet_ca_proxy_id, hostgroup.try(:puppet_proxy_id), hostgroup.try(:puppet_ca_proxy_id)].compact.each do |p|
+      ids << p
+    end
+    ids.uniq.compact
+  end
+
+  def matching?
+    missing_ids.empty?
+  end
+
+  def missing_ids
+    Array.wrap(tax_location.try(:missing_ids)) + Array.wrap(tax_organization.try(:missing_ids))
+  end
+
+  def import_missing_ids
+    tax_location.import_missing_ids     if location
+    tax_organization.import_missing_ids if organization
+  end
+
+  private
+
+  def lookup_keys_params
+    return {} unless Setting["Enable_Smart_Variables_in_ENC"]
+
+    p = {}
+    klasses = all_puppetclasses.map(&:id).flatten
+    LookupKey.where(:puppetclass_id => klasses ).each do |k|
+      p[k.to_s] = k.value_for(self)
+    end unless klasses.empty?
+    p
+  end
+
+  def lookup_keys_class_params
+    Classification.new(:host => self).enc
+  end
+
+  def bmc_nic
+    interfaces.bmc.first
+  end
+
+  # ensure that host name is fqdn
+  # if the user inputted short name, the domain name will be appended
+  # this is done to ensure compatibility with puppet storeconfigs
+  def normalize_hostname
+    # no hostname was given or a domain was selected, since this is before validation we need to ignore
+    # it and let the validations to produce an error
+    return if name.empty?
+
+    # Remove whitespace
+    self.name.gsub!(/\s/,'')
+
+    if domain.nil? and name.match(/\./)
+      # try to assign the domain automatically based on our existing domains from the host FQDN
+      self.domain = Domain.all.select{|d| name.match(d.name)}.first rescue nil
+    else
+      # if our host is in short name, append the domain name
+      if !new_record? and changed_attributes['domain_id'].present?
+        old_domain = Domain.find(changed_attributes["domain_id"])
+        self.name.gsub(old_domain.to_s,"")
+      end
+      self.name += ".#{domain}" unless name =~ /.#{domain}$/i
+    end
+  end
+
+  def assign_hostgroup_attributes attrs = []
+    attrs.each do |attr|
+      eval("self.#{attr.to_s} ||= hostgroup.#{attr.to_s}")
+    end
+  end
+
+  # checks if the host association is a valid association for this host
+  def ensure_associations
+    status = true
+    %w{ ptable medium architecture}.each do |e|
+      value = self.send(e.to_sym)
+      next if value.blank?
+      unless os.send(e.pluralize.to_sym).include?(value)
+        errors.add("#{e}_id".to_sym, _("%{value} does not belong to %{os} operating system") % { :value => value, :os => os })
+        status = false
+      end
+    end if SETTINGS[:unattended] and managed? and os and capabilities.include?(:build)
+
+    puppetclasses.select("puppetclasses.id,puppetclasses.name").uniq.each do |e|
+      unless environment.puppetclasses.map(&:id).include?(e.id)
+        errors.add(:puppetclasses, "#{e} does not belong to the #{environment} environment")
+        status = false
+      end
+    end if environment
+    status
+  end
+
+  # alias to ensure same method that resolves the last report between the hosts and reports tables.
+  def reported_at
+    last_report
+  end
+
+  # puppet report status table column name
+  def self.report_status
+    "puppet_status"
+  end
+
+  # converts a name into ip address using DNS.
+  # if we are managing DNS, we can query the correct DNS server
+  # otherwise, use normal systems dns settings to resolv
+  def to_ip_address name_or_ip
+    return name_or_ip if name_or_ip =~ Net::Validations::IP_REGEXP
+    return dns_ptr_record.dns_lookup(name_or_ip).ip if dns_ptr_record
+    # fall back to normal dns resolution
+    domain.resolver.getaddress(name_or_ip).to_s
+  end
+
+  def set_default_user
+    self.owner ||= User.current
+  end
+
+  def set_certname
+    self.certname = Foreman.uuid if read_attribute(:certname).blank? or new_record?
+  end
+
+  def normalize_addresses
+    self.mac = Net::Validations.normalize_mac(mac)
+    self.ip  = Net::Validations.normalize_ip(ip)
+  end
+
+  def force_lookup_value_matcher
+    lookup_values.each { |v| v.match = "fqdn=#{fqdn}" }
+  end
+
+  def tax_location
+    return nil unless location_id
+    @tax_location ||= TaxHost.new(location, self)
+  end
+
+  def tax_organization
+    return nil unless organization_id
+    @tax_organization ||= TaxHost.new(organization, self)
+  end
+
+
+end