foreman_discovery 1.0.0 → 1.0.2

data/test/foreman_app/app/models/smart_proxies/puppet_ca.rb

@@ -1,66 +0,0 @@
-require_dependency "proxy_api"
-require "time"
-
-class SmartProxies::PuppetCA
-
-  attr_reader :name, :state, :fingerprint, :valid_from, :expires_at, :smart_proxy_id
-
-  def initialize opts
-    @name, @state, @fingerprint, @valid_from, @expires_at, @smart_proxy_id = opts.flatten
-    @valid_from = Time.parse(@valid_from) unless @valid_from.blank?
-    @expires_at = Time.parse(@expires_at) unless @expires_at.blank?
-  end
-
-    class << self
-
-      def all(proxy)
-        raise ::Foreman::Exception(N_("Must specify a Smart Proxy to use")) if proxy.nil?
-
-        unless (certs = Rails.cache.read("ca_#{proxy.id}"))
-          api = ProxyAPI::Puppetca.new({:url => proxy.url})
-
-          certs = api.all.map do |name, properties|
-            new([name.strip, properties['state'], properties['fingerprint'], properties["not_before"], properties["not_after"], proxy.id])
-          end.compact
-
-          # save our CA details for 5 seconds
-          Rails.cache.write("ca_#{proxy.id}", certs, {:expires_in  => 1.minute }) if Rails.env.production?
-        end
-        certs
-      end
-
-      def find(proxy, name)
-        all(proxy).select{|c| c.name == name}.first
-      rescue
-        raise ActiveRecord::RecordNotFound
-      end
-
-      def find_by_state(proxy, state)
-         all(proxy).select{|c| c.state == state}
-      rescue
-        raise ActiveRecord::RecordNotFound
-      end
-    end
-
-  def sign
-    raise ::Foreman::Exception(N_("unable to sign a non pending certificate")) unless state == "pending"
-    proxy = SmartProxy.find(smart_proxy_id)
-    Rails.cache.delete("ca_#{proxy.id}") if Rails.env.production?
-    ProxyAPI::Puppetca.new({:url => proxy.url}).sign_certificate name
-  end
-
-  def destroy
-    proxy = SmartProxy.find(smart_proxy_id)
-    Rails.cache.delete("ca_#{proxy.id}") if Rails.env.production?
-    ProxyAPI::Puppetca.new({:url => proxy.url}).del_certificate name
-  end
-
-  def to_param; name end
-
-  def to_s; name end
-
-  def <=> other
-    self.name <=> other.name
-  end
-
-end

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

@@ -1,96 +0,0 @@
-class SmartProxy < ActiveRecord::Base
-  include Authorization
-  include Taxonomix
-  ProxyFeatures = %w[ TFTP BMC DNS DHCP Puppetca Puppet]
-  attr_accessible :name, :url, :location_ids, :organization_ids
-  #TODO check if there is a way to look into the tftp_id too
-  # maybe with a predefined sql
-  has_and_belongs_to_many :features
-  has_many :subnets,    :foreign_key => "dhcp_id"
-  has_many :domains,    :foreign_key => "dns_id"
-  has_many_hosts        :foreign_key => "puppet_proxy_id"
-  has_many :hostgroups, :foreign_key => "puppet_proxy_id"
-
-  URL_HOSTNAME_MATCH = %r{^(?:http|https):\/\/([^:\/]+)}
-  validates_uniqueness_of :name
-  validates_presence_of :name, :url
-  validates_format_of :url, :with => URL_HOSTNAME_MATCH, :message => N_("is invalid - only  http://, https:// are allowed")
-  validates_uniqueness_of :url, :message => N_("Only one declaration of a proxy is allowed")
-
-  # There should be no problem with associating features before the proxy is saved as the whole operation is in a transaction
-  before_save :sanitize_url, :associate_features
-  before_destroy EnsureNotUsedBy.new(:subnets, :domains, :hosts, :hostgroups)
-
-  # with proc support, default_scope can no longer be chained
-  # include all default scoping here
-  default_scope lambda {
-    with_taxonomy_scope do
-      order("LOWER(smart_proxies.name)")
-    end
-  }
-  ProxyFeatures.each {|f| scope "#{f.downcase}_proxies".to_sym, where(:features => {:name => f}).joins(:features) }
-
-  def hostname
-    # This will always match as it is validated
-    url.match(URL_HOSTNAME_MATCH)[1]
-  end
-
-  def to_s
-    hostname =~ /^puppet\./ ? "puppet" : hostname
-  end
-
-  def to_param
-    "#{id}-#{name.parameterize}"
-  end
-
-  def self.name_map
-    {
-      "tftp"     => Feature.find_by_name("TFTP"),
-      "bmc"      => Feature.find_by_name("BMC"),
-      "dns"      => Feature.find_by_name("DNS"),
-      "dhcp"     => Feature.find_by_name("DHCP"),
-      "puppetca" => Feature.find_by_name("Puppet CA"),
-      "puppet"   => Feature.find_by_name("Puppet")
-    }
-  end
-
-  def self.smart_proxy_ids_for(hosts)
-    ids = []
-    ids << hosts.joins(:subnet).pluck('DISTINCT subnets.dhcp_id')
-    ids << hosts.joins(:subnet).pluck('DISTINCT subnets.tftp_id')
-    ids << hosts.joins(:subnet).pluck('DISTINCT subnets.dns_id')
-    ids << hosts.joins(:domain).pluck('DISTINCT domains.dns_id')
-    ids << hosts.pluck('DISTINCT puppet_proxy_id')
-    ids << hosts.pluck('DISTINCT puppet_ca_proxy_id')
-    ids << hosts.joins(:hostgroup).pluck('DISTINCT hostgroups.puppet_proxy_id')
-    ids << hosts.joins(:hostgroup).pluck('DISTINCT hostgroups.puppet_ca_proxy_id')
-    # returned both 7, "7". need to convert to integer or there are duplicates
-    ids.flatten.compact.map{|i| i.to_i}.uniq
-  end
-
-  private
-
-  def sanitize_url
-    self.url.chomp!("/") unless url.empty?
-  end
-
-  def associate_features
-    return true if Rails.env == "test"
-
-    name_map = SmartProxy.name_map
-    reason = false
-    self.features.clear
-    begin
-      reply = ProxyAPI::Features.new(:url => url).features
-      if reply.is_a?(Array) and reply.any?
-        self.features = reply.map{|f| name_map[f]}
-      else
-        errors.add :base, _("No features found on this proxy, please make sure you enable at least one feature")
-      end
-    rescue => e
-      errors.add(:base, _("Unable to communicate with the proxy: %s") % e)
-      errors.add(:base, _("Please check the proxy is configured and running on the host before saving."))
-    end
-    features.any?
-  end
-end

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

@@ -1,114 +0,0 @@
-class Solaris < Operatingsystem
-  PXEFILES = {:initrd => "x86.miniroot", :kernel => "multiboot"}
-
-  def file_prefix
-    "#{to_s}".gsub(/[\s\(\)]/,"-").gsub("--", "-").gsub(/-$/, "")
-  end
-
-  # sets the prefix for the tftp files based on the OS
-  def pxe_prefix(architecture=nil)
-    "boot/#{file_prefix}"
-  end
-
-  def to_label
-    "#{super}#{(' (' + release_name + ')') unless release_name.empty?}"
-  end
-
-  # The PXE type to use when generating actions and evaluating attributes. jumpstart, kickstart and preseed are currently supported.
-  def pxe_type
-    "jumpstart"
-  end
-
-  # The variant to use when communicating with the proxy. Syslinux are pxegrub currently supported
-  def pxe_variant
-    "pxegrub"
-  end
-
-  # The kind of PXE configuration template used. PXELinux and PXEGrub are currently supported
-  def template_kind
-    "PXEGrub"
-  end
-
-  def pxedir
-    "Solaris_#{minor}/Tools/Boot"
-  end
-
-  def url_for_boot(file)
-    pxedir + "/" + PXEFILES[file]
-  end
-
-  def boot_filename host
-    #handle things like gpxelinux/ gpxe / pxelinux here
-    if host.jumpstart?
-      "Solaris-#{major}.#{minor}-#{release_name}-#{host.model.hardware_model}-inetboot"
-    else
-      "Solaris-5.#{minor}-#{release_name}-pxegrub"
-    end
-  end
-
-  def pxeconfig_default
-    "boot/grub/menu.lst"
-  end
-
-  # If this OS family requires access to its media via NFS
-  def require_nfs_access_to_medium
-    true
-  end
-
-  # Calculates the media's path in relation to the domain and convert host to an IP
-  def media_path medium, domain
-    resolv_nfs_path medium.media_host, medium.media_dir, domain
-  end
-
-  # Calculates the jumpstart's path in relation to the domain and convert host to an IP
-  def jumpstart_path medium, domain
-    resolv_nfs_path medium.jumpstart_host, medium.jumpstart_dir, domain
-  end
-  # Override the class representation, as this breaks many rails helpers
-  def class
-    Operatingsystem
-  end
-
-  # Does this OS family support a build variant that is constructed from a prebuilt archive
-  def supports_image
-    true
-  end
-
-  def image_extension
-    "flar"
-  end
-
-  # Does this OS family use release_name in its naming scheme
-  def use_release_name?
-    true
-  end
-
-  def jumpstart_params host, vendor
-    # root server and install server are always the same under Foreman
-    server_name = host.medium.media_host
-    server_ip   = host.domain.resolver.getaddress(server_name).to_s
-    jpath       = jumpstart_path host.medium, host.domain
-    ipath       = interpolate_medium_vars(host.medium.media_dir, host.architecture.name, self)
-
-    {
-      :vendor => "<#{vendor}>",
-      :root_server_ip        => server_ip,                              # 192.168.216.241
-      :root_server_hostname  => server_name,                            # mediahost
-      :root_path_name        => "#{ipath}/Solaris_#{minor}/Tools/Boot", # /vol/solgi_5.10/sol10_hw0910/Solaris_10/Tools/Boot
-      :install_server_ip     => server_ip,                              # 192.168.216.241
-      :install_server_name   => server_name,                            # mediahost
-      :install_path          => ipath,                                  # /vol/solgi_5.10/sol10_hw0910
-      :sysid_server_path     => "#{jpath}/sysidcfg/sysidcfg_primary",   # 192.168.216.241:/vol/jumpstart/sysidcfg/sysidcfg_primary
-      :jumpstart_server_path => jpath,                                  # 192.168.216.241:/vol/jumpstart
-    }
-  end
-
-  private
-  def resolv_nfs_path host, dir, domain
-    host = host + ".#{domain.name}" unless host =~ /\./
-    # If host is already an IP then this works fine
-    ip = domain.resolver.getaddress(host)
-    "#{ip}:#{dir}"
-  end
-
-end

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

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

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

@@ -1,146 +0,0 @@
-require 'ipaddr'
-class Subnet < ActiveRecord::Base
-  include Authorization
-  include Taxonomix
-
-  has_many_hosts
-  belongs_to :dhcp, :class_name => "SmartProxy"
-  belongs_to :tftp, :class_name => "SmartProxy"
-  belongs_to :dns,  :class_name => "SmartProxy"
-  has_many :subnet_domains, :dependent => :destroy
-  has_many :domains, :through => :subnet_domains
-  has_many :interfaces, :class_name => 'Nic::Base'
-  validates_presence_of   :network, :mask, :name
-  validates_associated    :subnet_domains
-  validates_uniqueness_of :network
-  validates_format_of     :network, :mask,                        :with => Net::Validations::IP_REGEXP
-  validates_format_of     :gateway, :dns_primary, :dns_secondary, :with => Net::Validations::IP_REGEXP, :allow_blank => true, :allow_nil => true
-  validate :name_should_be_uniq_across_domains
-
-  validate :validate_ranges
-
-  default_scope lambda {
-    with_taxonomy_scope do
-      order('vlanid')
-    end
-  }
-
-  before_destroy EnsureNotUsedBy.new(:hosts, :interfaces )
-
-  scoped_search :on => [:name, :network, :mask, :gateway, :dns_primary, :dns_secondary, :vlanid], :complete_value => true
-  scoped_search :in => :domains, :on => :name, :rename => :domain, :complete_value => true
-
-  class Jail < ::Safemode::Jail
-    allow :name, :network, :mask, :cidr, :title, :to_label, :gateway, :dns_primary, :dns_secondary, :vlanid
-  end
-
-  # Subnets are displayed in the form of their network network/network mask
-  def to_label
-    "#{network}/#{cidr}"
-  end
-
-  def title
-    "#{name} (#{to_label})"
-  end
-
-  # Subnets are sorted on their priority value
-  # [+other+] : Subnet object with which to compare ourself
-  # +returns+ : Subnet object with higher precedence
-  def <=> (other)
-    if self.vlanid.present? && other.vlanid.present?
-      self.vlanid <=> other.vlanid
-    else
-      return -1
-    end
-  end
-
-  # Given an IP returns the subnet that contains that IP
-  # [+ip+] : "doted quad" string
-  # Returns : Subnet object or nil if not found
-  def self.subnet_for(ip)
-    Subnet.all.each {|s| return s if s.contains? IPAddr.new(ip)}
-    nil
-  end
-
-  # Indicates whether the IP is within this subnet
-  # [+ip+] String: Contains 4 dotted decimal values
-  # Returns Boolean: True if if ip is in this subnet
-  def contains? ip
-    IPAddr.new("#{network}/#{mask}", Socket::AF_INET).include? IPAddr.new(ip, Socket::AF_INET)
-  end
-
-  def cidr
-    IPAddr.new(mask).to_i.to_s(2).count("1")
-  end
-
-  def dhcp?
-    !!(dhcp and dhcp.url and !dhcp.url.blank?)
-  end
-
-  def dhcp_proxy attrs = {}
-    @dhcp_proxy ||= ProxyAPI::DHCP.new({:url => dhcp.url}.merge(attrs)) if dhcp?
-  end
-
-  def tftp?
-    !!(tftp and tftp.url and !tftp.url.blank?)
-  end
-
-  def tftp_proxy attrs = {}
-    @tftp_proxy ||= ProxyAPI::TFTP.new({:url => tftp.url}.merge(attrs)) if tftp?
-  end
-
-  # do we support DNS PTR records for this subnet
-  def dns?
-    !!(dns and dns.url and !dns.url.blank?)
-  end
-
-  def dns_proxy attrs = {}
-    @dns_proxy ||= ProxyAPI::DNS.new({:url => dns.url}.merge(attrs)) if dns?
-  end
-
-  def unused_ip mac = nil
-    return unless dhcp?
-    dhcp_proxy.unused_ip(self, mac)["ip"]
-  rescue => e
-    logger.warn "Failed to fetch a free IP from our proxy: #{e}"
-    nil
-  end
-
-  # imports subnets from a dhcp smart proxy
-  def self.import proxy
-    return unless proxy.features.include?(Feature.find_by_name("DHCP"))
-    ProxyAPI::DHCP.new(:url => proxy.url).subnets.map do |s|
-      # do not import existing networks.
-      attrs = { :network => s["network"], :mask => s["netmask"] }
-      next if first(:conditions => attrs)
-      new(attrs.update(:dhcp => proxy))
-    end.compact
-  end
-
-  def as_json options = {}
-    options ||= {}
-    super({:methods => [:cidr, :to_label]}.merge(options))
-  end
-
-  private
-
-  def validate_ranges
-    errors.add(:from, _("invalid IP address"))            if from.present? and !from =~ Net::Validations::IP_REGEXP
-    errors.add(:to, _("invalid IP address"))              if to.present?   and !to   =~ Net::Validations::IP_REGEXP
-    errors.add(:from, _("does not belong to subnet"))     if from.present? and not self.contains?(f=IPAddr.new(from))
-    errors.add(:to, _("does not belong to subnet"))       if to.present?   and not self.contains?(t=IPAddr.new(to))
-    errors.add(:from, _("can't be bigger than to range")) if from.present? and t.present? and f > t
-    if from.present? or to.present?
-      errors.add(:from, _("must be specified if to is defined"))   if from.blank?
-      errors.add(:to,   _("must be specified if from is defined")) if to.blank?
-    end
-  end
-
-  def name_should_be_uniq_across_domains
-    return if domains.empty?
-    domains.each do |d|
-      conds = new_record? ? ['name = ?', name] : ['subnets.name = ? AND subnets.id != ?', name, id]
-      errors.add(:name, _("domain %s already has a subnet with this name") % d) if d.subnets.where(conds).first
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-class SubnetDomain < ActiveRecord::Base
-  belongs_to :domain
-  belongs_to :subnet
-
-  validates_presence_of :subnet_id, :domain_id
-  validates_uniqueness_of :domain_id, :scope => :subnet_id
-
-  def to_s
-    "#{domain} : #{subnet}"
-  end
-
-end