foreman_discovery 1.0.0.rc1

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

@@ -0,0 +1,172 @@
+class ConfigTemplate < ActiveRecord::Base
+  include Authorization
+  include Taxonomix
+  audited
+  self.auditing_enabled = !(File.basename($0) == "rake" && ARGV.include?("db:migrate"))
+  attr_accessible :name, :template, :template_kind_id, :snippet, :template_combinations_attributes, :operatingsystem_ids, :audit_comment
+  validates_presence_of :name, :template
+  validates_presence_of :template_kind_id, :unless => Proc.new {|t| t.snippet }
+  validates_uniqueness_of :name
+  has_many :hostgroups, :through => :template_combinations
+  has_many :environments, :through => :template_combinations
+  has_many :template_combinations, :dependent => :destroy
+  belongs_to :template_kind
+  accepts_nested_attributes_for :template_combinations, :allow_destroy => true, :reject_if => lambda {|tc| tc[:environment_id].blank? and tc[:hostgroup_id].blank? }
+  has_and_belongs_to_many :operatingsystems
+  has_many :os_default_templates
+  before_save :check_for_snippet_assoications, :remove_trailing_chars
+  before_destroy EnsureNotUsedBy.new(:hostgroups, :environments, :os_default_templates)
+  # with proc support, default_scope can no longer be chained
+  # include all default scoping here
+  default_scope lambda {
+    with_taxonomy_scope do
+      order("LOWER(config_templates.name)")
+    end
+  }
+
+  scoped_search :on => :name,    :complete_value => true, :default_order => true
+  scoped_search :on => :snippet, :complete_value => true, :complete_value => {:true => true, :false => false}
+  scoped_search :on => :template
+
+  scoped_search :in => :operatingsystems, :on => :name, :rename => :operatingsystem, :complete_value => true
+  scoped_search :in => :environments,     :on => :name, :rename => :environment,     :complete_value => true
+  scoped_search :in => :hostgroups,       :on => :name, :rename => :hostgroup,       :complete_value => true
+  scoped_search :in => :template_kind,    :on => :name, :rename => :kind,            :complete_value => true
+
+  class Jail < Safemode::Jail
+    allow :name
+  end
+
+  def to_param
+    "#{id}-#{name.parameterize}"
+  end
+
+  # TODO: review if we can improve SQL
+  def self.template_ids_for(hosts)
+    hosts.with_os.map do |host|
+      host.configTemplate.try(:id)
+    end.uniq.compact
+  end
+
+  def self.find_template opts = {}
+    raise ::Foreman::Exception(N_("Must provide template kind")) unless opts[:kind]
+    raise ::Foreman::Exception(N_("Must provide an operating systems")) unless opts[:operatingsystem_id]
+
+    # first filter valid templates to our OS and requested template kind.
+    templates = ConfigTemplate.joins(:operatingsystems, :template_kind).where('operatingsystems.id' => opts[:operatingsystem_id], 'template_kinds.name' => opts[:kind])
+
+
+    # once a template has been matched, we no longer look for others.
+
+    if opts[:hostgroup_id] and opts[:environment_id]
+      # try to find a full match to our host group and environment
+      template = templates.joins(:hostgroups, :environments).where("hostgroups.id" => opts[:hostgroup_id], "environments.id" => opts[:environment_id]).first
+    end
+
+    if opts[:hostgroup_id]
+      # try to find a match with our hostgroup only
+      template ||= templates.joins(:hostgroups).where("hostgroups.id" => opts[:hostgroup_id]).first
+    end
+
+    if opts[:environment_id]
+      # search for a template based only on our environment
+      template ||= templates.joins(:environments).where("environments.id" => opts[:environment_id]).first
+    end
+
+    # fall back to the os default template
+    template ||= templates.joins(:os_default_templates).where("os_default_templates.operatingsystem_id" => opts[:operatingsystem_id]).first
+    template.is_a?(ConfigTemplate) ? template : nil
+  end
+
+  def enforce_permissions operation
+    # We get called again with the operation being set to create
+    return true if operation == "edit" and new_record?
+
+    return true if User.current and User.current.allowed_to?("#{operation}_templates".to_sym)
+
+    errors.add :base, (_("You do not have permission to %s this template") % operation)
+    false
+  end
+
+  def as_json(options={})
+    options ||= {}
+    super({:only => [:name, :template, :id, :snippet],:include => [:template_kind]}.merge(options))
+  end
+
+  def self.build_pxe_default(renderer)
+    if (proxies = SmartProxy.tftp_proxies).empty?
+      error_msg = _("No TFTP proxies defined, can't continue")
+    end
+
+    if (default_template = ConfigTemplate.find_by_name("PXE Default File")).nil?
+      error_msg = _("Could not find a Configuration Template with the name \"PXE Default File\", please create one.")
+    end
+
+    if error_msg.empty?
+      begin
+        @profiles = pxe_default_combos
+        menu = renderer.render_safe(default_template.template, [:default_template_url], {:profiles => @profiles})
+      rescue => e
+        error_msg = _("failed to process template: %s" % e)
+      end
+    end
+
+    return [422, error_msg] unless error_msg.empty?
+
+    error_msgs = []
+    proxies.each do |proxy|
+      begin
+        tftp = ProxyAPI::TFTP.new(:url => proxy.url)
+        tftp.create_default({:menu => menu})
+
+        @profiles.each do |combo|
+          combo[:hostgroup].operatingsystem.pxe_files(combo[:hostgroup].medium, combo[:hostgroup].architecture).each do |bootfile_info|
+            for prefix, path in bootfile_info do
+              tftp.fetch_boot_file(:prefix => prefix.to_s, :path => path)
+            end
+          end
+        end
+      rescue => exc
+        error_msgs << "#{proxy}: #{exc.message}"
+      end
+    end
+
+    unless error_msgs.empty?
+      msg = _("There was an error creating the PXE Default file: %s") % error_msgs.join(",")
+      return [500, msg]
+    end
+
+    return [200, _("PXE Default file has been deployed to all Smart Proxies")]
+  end
+
+  private
+
+  # check if our template is a snippet, and remove its associations just in case they were selected.
+  def check_for_snippet_assoications
+    return unless snippet
+    self.hostgroups.clear
+    self.environments.clear
+    self.template_combinations.clear
+    self.operatingsystems.clear
+    self.template_kind = nil
+  end
+
+  def remove_trailing_chars
+    self.template.gsub!("\r","") unless template.empty?
+  end
+
+  # get a list of all hostgroup, template combinations that a pxemenu will be
+  # generated for
+  def self.pxe_default_combos
+    combos = []
+    ConfigTemplate.joins(:template_kind).where("template_kinds.name" => "provision").includes(:template_combinations => [:environment, {:hostgroup => [ :operatingsystem, :architecture, :medium]}]).each do |template|
+      template.template_combinations.each do |combination|
+        hostgroup = combination.hostgroup
+        if hostgroup and hostgroup.operatingsystem and hostgroup.architecture and hostgroup.medium
+          combos << {:hostgroup => hostgroup, :template => template}
+        end
+      end
+    end
+    combos
+  end
+end

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

@@ -0,0 +1,53 @@
+class Dashboard
+
+  attr_reader :report
+  # returns a status hash
+  def self.status(filter="")
+    new(filter).report
+  end
+
+  def initialize(filter="")
+    @filter = filter
+    @report = {}
+    fetch_data
+  end
+
+  def hosts
+    @hosts ||= Host.my_hosts.search_for(filter)
+  end
+
+  private
+  attr_writer :report
+  attr_accessor :filter
+  def fetch_data
+      report.update({
+          :total_hosts               => hosts.count,
+          :bad_hosts                 => hosts.recent.with_error.count,
+          :bad_hosts_enabled         => hosts.recent.with_error.alerts_enabled.count,
+          :active_hosts              => hosts.recent.with_changes.count,
+          :active_hosts_ok           => hosts.recent.with_changes.without_error.count,
+          :active_hosts_ok_enabled   => hosts.recent.with_changes.without_error.alerts_enabled.count,
+          :ok_hosts                  => hosts.recent.successful.count,
+          :ok_hosts_enabled          => hosts.recent.successful.alerts_enabled.count,
+          :out_of_sync_hosts         => hosts.out_of_sync.count,
+          :out_of_sync_hosts_enabled => hosts.out_of_sync.alerts_enabled.count,
+          :disabled_hosts            => hosts.alerts_disabled.count,
+          :pending_hosts             => hosts.recent.with_pending_changes.count,
+          :pending_hosts_enabled     => hosts.recent.with_pending_changes.alerts_enabled.count,
+      })
+      report[:good_hosts]         = report[:ok_hosts]         + report[:active_hosts_ok]
+      report[:good_hosts_enabled] = report[:ok_hosts_enabled] + report[:active_hosts_ok_enabled]
+      report[:percentage]         = percentage
+      report[:reports_missing]    = reports_missing
+  end
+
+  def percentage
+    return 0 if report[:ok_hosts_enabled] == 0 or report[:total_hosts] == 0
+    report[:ok_hosts_enabled] * 100 / report[:total_hosts]
+  end
+
+  def reports_missing
+    hosts.search_for('not has last_report and status.enabled = true').count
+  end
+
+end

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

@@ -0,0 +1,47 @@
+class Debian < Operatingsystem
+
+  PXEFILES = {:kernel => "linux", :initrd => "initrd.gz"}
+
+  def preseed_server host
+    medium_uri(host).select(:host, :port).compact.join(':')
+  end
+
+  def preseed_path host
+    medium_uri(host).select(:path, :query).compact.join('?')
+  end
+
+  # Override the class representation, as this breaks many rails helpers
+  def class
+    Operatingsystem
+  end
+
+  def boot_files_uri(medium, architecture)
+    raise ::Foreman::Exception(N_("invalid medium for %s"), to_s) unless media.include?(medium)
+    raise ::Foreman::Exception(N_("invalid architecture for %s"), to_s) unless architectures.include?(architecture)
+
+    # Debian stores x86_64 arch is amd64
+    arch = architecture.to_s.gsub("x86_64","amd64")
+    pxe_dir = "dists/#{release_name}/main/installer-#{arch}/current/images/netboot/#{guess_os}-installer/#{arch}"
+
+    PXEFILES.values.collect do |img|
+      URI.parse("#{medium_vars_to_uri(medium.path, architecture.name, self)}/#{pxe_dir}/#{img}").normalize
+    end
+  end
+
+  def pxe_type
+    "preseed"
+  end
+
+  # Does this OS family use release_name in its naming scheme
+  def use_release_name?
+    true
+  end
+
+  private
+
+  # tries to guess if this an ubuntu or a debian os
+  def guess_os
+    name =~ /ubuntu/i ? "ubuntu" : "debian"
+  end
+
+end

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

@@ -0,0 +1,90 @@
+require "resolv"
+# This models a DNS domain and so represents a site.
+class Domain < ActiveRecord::Base
+  include Authorization
+  include Taxonomix
+
+  has_many_hosts
+  has_many :hostgroups
+  #order matters! see https://github.com/rails/rails/issues/670
+  before_destroy EnsureNotUsedBy.new(:hosts, :hostgroups, :subnets)
+  has_many :subnet_domains, :dependent => :destroy
+  has_many :subnets, :through => :subnet_domains
+  belongs_to :dns, :class_name => "SmartProxy"
+  has_many :domain_parameters, :dependent => :destroy, :foreign_key => :reference_id
+  has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "DomainParameter"
+  has_and_belongs_to_many :users, :join_table => "user_domains"
+  has_many :interfaces, :class_name => 'Nic::Base'
+
+  accepts_nested_attributes_for :domain_parameters, :reject_if => lambda { |a| a[:value].blank? }, :allow_destroy => true
+  validates_uniqueness_of :name
+  validates_uniqueness_of :fullname, :allow_blank => true, :allow_nil => true
+  validates_presence_of :name
+
+  scoped_search :on => [:name, :fullname], :complete_value => true
+  scoped_search :in => :domain_parameters,    :on => :value, :on_key=> :name, :complete_value => true, :only_explicit => true, :rename => :params
+
+  # with proc support, default_scope can no longer be chained
+  # include all default scoping here
+  default_scope lambda {
+    with_taxonomy_scope do
+      order("LOWER(domains.name)")
+    end
+  }
+
+  class Jail < Safemode::Jail
+    allow :name, :fullname
+  end
+
+  def to_param
+    name
+  end
+
+  def as_json(options={})
+    options ||= {}
+    super({:only => [:name, :id]}.merge(options))
+  end
+
+  def enforce_permissions operation
+    # We get called again with the operation being set to create
+    return true if operation == "edit" and new_record?
+
+    current = User.current
+
+    if current.allowed_to?("#{operation}_domains".to_sym)
+      # If you can create domains then you can create them anywhere
+      return true if operation == "create"
+      # However if you are editing or destroying and you have a domain list then you are constrained
+      if current.domains.empty? or current.domains.map(&:id).include? self.id
+        return true
+      end
+    end
+
+    errors.add(:base, _("You do not have permission to %s this domain") % operation)
+    false
+  end
+
+  # return the primary name server for our domain based on DNS lookup
+  # it first searches for SOA record, if it failed it will search for NS records
+  def nameservers
+    return [] if Setting.query_local_nameservers
+    dns = Resolv::DNS.new
+    ns = dns.getresources(name, Resolv::DNS::Resource::IN::SOA).collect {|r| r.mname.to_s}
+    ns = dns.getresources(name, Resolv::DNS::Resource::IN::NS).collect {|r| r.name.to_s} if ns.empty?
+    ns.to_a.flatten
+  end
+
+  def resolver
+    ns = nameservers
+    Resolv::DNS.new ns.empty? ? nil : {:search => name, :nameserver => ns, :ndots => 1}
+  end
+
+  def proxy
+    ProxyAPI::DNS.new(:url => dns.url) if dns and !dns.url.blank?
+  end
+
+  def lookup query
+    Net::DNS.lookup query, proxy, resolver
+  end
+
+end

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

@@ -0,0 +1,22 @@
+class DomainParameter < Parameter
+  belongs_to :domain, :foreign_key => :reference_id
+  audited :except => [:priority], :associated_with => :domain
+  validates_uniqueness_of :name, :scope => :reference_id
+
+  private
+  def enforce_permissions operation
+    # We get called again with the operation being set to create
+    return true if operation == "edit" and new_record?
+
+    current = User.current
+
+    if current.allowed_to?("#{operation}_domains".to_sym)
+      if current.domains.empty? or current.domains.include? domain
+        return true
+      end
+    end
+
+    errors.add(:base, _("You do not have permission to %s this domain parameter") % operation)
+    false
+  end
+end

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

@@ -0,0 +1,57 @@
+class Environment < ActiveRecord::Base
+  include Taxonomix
+  include Authorization
+
+  has_many :environment_classes, :dependent => :destroy
+  has_many :puppetclasses, :through => :environment_classes, :uniq => true
+  has_many_hosts
+  has_many :trends, :as => :trendable, :class_name => "ForemanTrend"
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  validates_format_of :name, :with => /^[\w\d]+$/, :message => N_("is alphanumeric and cannot contain spaces")
+  has_many :config_templates, :through => :template_combinations, :dependent => :destroy
+  has_many :template_combinations
+
+  before_destroy EnsureNotUsedBy.new(:hosts)
+
+  # with proc support, default_scope can no longer be chained
+  # include all default scoping here
+  default_scope lambda {
+    with_taxonomy_scope do
+      order("environments.name")
+    end
+  }
+
+  scoped_search :on => :name, :complete_value => :true
+
+  def to_param
+    name
+  end
+
+  class << self
+
+    #TODO: this needs to be removed, as PuppetDOC generation no longer works
+    # if the manifests are not on the foreman host
+    # returns an hash of all puppet environments and their relative paths
+    def puppetEnvs proxy = nil
+
+      url = (proxy || SmartProxy.puppet_proxies.first).try(:url)
+      raise ::Foreman::Exception.new(N_("Can't find a valid Foreman Proxy with a Puppet feature")) if url.blank?
+      proxy = ProxyAPI::Puppet.new :url => url
+      HashWithIndifferentAccess[proxy.environments.map { |e|
+        [e, HashWithIndifferentAccess[proxy.classes(e).map {|k|
+          klass = k.keys.first
+          [klass, k[klass]["params"]]
+        }]]
+      }]
+    end
+
+  end
+
+  def as_json(options={ })
+    options ||= { }
+    super({ :only => [:name, :id] }.merge(options))
+  end
+
+end