foreman_discovery 1.0.0 → 1.0.2

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

@@ -1,24 +0,0 @@
-class Organization < Taxonomy
-  include Foreman::ThreadSession::OrganizationModel
-
-  has_and_belongs_to_many :locations
-  has_many_hosts :dependent => :nullify
-
-  scope :completer_scope, lambda { my_organizations }
-
-  scope :my_organizations, lambda {
-      user = User.current
-      if user.admin?
-        conditions = { }
-      else
-        conditions = sanitize_sql_for_conditions([" (taxonomies.id in (?))", user.organization_ids])
-      end
-      where(conditions).reorder('type, name')
-    }
-
-  def dup
-    new = super
-    new.locations = locations
-    new
-  end
-end

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

@@ -1,11 +0,0 @@
-class OsDefaultTemplate < ActiveRecord::Base
-  belongs_to :config_template
-  belongs_to :template_kind
-  belongs_to :operatingsystem
-  validates_presence_of :config_template_id, :template_kind_id
-  validates_uniqueness_of :template_kind_id, :scope => :operatingsystem_id
-
-  def name
-    "#{operatingsystem} - #{template_kind}"
-  end
-end

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

@@ -1,16 +0,0 @@
-class OsParameter < Parameter
-  belongs_to :operatingsystem, :foreign_key => :reference_id
-  audited :except => [:priority], :associated_with => :operatingsystem
-  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?
-    return true if User.current.allowed_to?("#{operation}_operatingsystems".to_sym)
-
-    errors.add(:base, _("You do not have permission to %s this Operating System parameter") % operation)
-    false
-  end
-
-end

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

@@ -1,34 +0,0 @@
-class Parameter < ActiveRecord::Base
-  belongs_to_host :foreign_key => :reference_id
-  include Authorization
-
-  validates_presence_of   :name, :value
-  validates_format_of     :name,  :without => /\s/, :message => N_("can't contain white spaces")
-
-  validates_presence_of :reference_id, :message => N_("parameters require an associated domain, host or hostgroup"), :unless => Proc.new {|p| p.nested or p.is_a? CommonParameter}
-
-  attr_accessor :nested
-  before_validation :strip_whitespaces
-  after_initialize :set_priority
-
-  PRIORITY = {:common_parameter => 0, :domain_parameter => 1, :os_parameter => 2, :group_parameter => 3 , :host_parameter => 4}
-
-  def self.reassign_priorities
-    # priorities will be reassigned because of after_initialize
-    find_in_batches do |params|
-      params.each { |param| param.update_attribute(:priority, param.priority) }
-    end
-  end
-
-  private
-
-  def set_priority
-    t = read_attribute(:type)
-    self.priority = PRIORITY[t.to_s.underscore.to_sym] unless t.blank?
-  end
-
-  def strip_whitespaces
-    self.name = self.name.strip  unless name.blank? # when name string comes from a hash key, it's frozen and cannot be modified
-    self.value.strip! unless value.blank?
-  end
-end

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

@@ -1,25 +0,0 @@
-# This models the partition tables for a disk layouts
-# It supports both static partition maps and dynamic scripts that create partition tables on-the-fly
-# A host object may contain a reference to one of these ptables or, alternatively, it may contain a
-# modified version of one of these in textual form
-class Ptable < ActiveRecord::Base
-  include Authorization
-
-  has_many_hosts
-  has_and_belongs_to_many :operatingsystems
-  before_destroy EnsureNotUsedBy.new(:hosts)
-  validates_uniqueness_of :name
-  validates_presence_of :layout
-  validates_format_of :name, :with => /\A(\S+\s?)+\Z/, :message => N_("can't be blank or contain trailing white spaces.")
-  default_scope :order => 'LOWER(ptables.name)'
-
-  scoped_search :on => :name, :complete_value => true, :default_order => true
-  scoped_search :on => :layout, :complete_value => false
-  scoped_search :on => :os_family, :rename => "family", :complete_value => :true
-
-  def as_json(options={})
-    options ||= {}
-    super({:only => [:name, :id]}.merge(options))
-  end
-
-end

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

@@ -1,269 +0,0 @@
-class PuppetClassImporter
-
-  def initialize args = { }
-    @foreman_classes = { }
-    @proxy_classes   = { }
-    if args[:proxy]
-      @proxy = args[:proxy]
-    elsif args[:url]
-      @proxy = ProxyAPI::Puppet.new(:url => args[:url])
-    else
-      url = SmartProxy.puppet_proxies.first.try(:url)
-      raise "Can't find a valid Proxy with a Puppet feature" if url.blank?
-      @proxy = ProxyAPI::Puppet.new(:url => url)
-    end
-  end
-
-  # return changes hash, currently exists to keep compatibility with importer html
-  def changes
-    changes = { 'new' => { }, 'obsolete' => { }, 'updated' => { } }
-
-    actual_environments.each do |env|
-      new     = new_classes_for(env)
-      old     = removed_classes_for(env)
-      updated = updated_classes_for(env)
-      changes['new'][env] = new if new.any?
-      changes['obsolete'][env] = old if old.any?
-      changes['updated'][env] = updated if updated.any?
-    end
-
-    old_environments.each do |env|
-      changes['obsolete'][env] ||= []
-      changes['obsolete'][env] << "_destroy_" unless actual_environments.include?(env)
-    end
-    changes
-  end
-
-  # Update the environments and puppetclasses based upon the user's selection
-  # It does a best attempt and can fail to perform all operations due to the
-  # user requesting impossible selections. Repeat the operation if errors are
-  # shown, after fixing the request.
-  # +changed+ : Hash with two keys: :new and :obsolete.
-  #               changed[:/new|obsolete/] is and Array of Strings
-  # Returns   : Array of Strings containing all record errors
-  def obsolete_and_new changes = { }
-    return if changes.empty?
-    changes.values.map(&:keys).flatten.uniq.each do |env_name|
-      if changes['new'] and changes['new'][env_name].try(:>, '') # we got new classes
-        add_classes_to_foreman(env_name, JSON.parse(changes['new'][env_name]))
-      end
-      if changes['obsolete'] and changes['obsolete'][env_name].try(:>, '') # we need to remove classes
-        remove_classes_from_foreman(env_name, JSON.parse(changes['obsolete'][env_name]))
-      end
-      if changes['updated'] and changes['updated'][env_name].try(:>, '') # we need to update classes
-        update_classes_in_foreman(env_name, JSON.parse(changes['updated'][env_name]))
-      end
-    end
-    []
-    #rescue => e
-    #  logger.error(e)
-    #  [e.to_s]
-  end
-
-  def new_classes_for environment
-    old_classes = db_classes_name(environment)
-    HashWithIndifferentAccess[
-      actual_classes(environment).values.map do |actual_class|
-        [actual_class.to_s, { "new" => actual_class.parameters }] unless old_classes.include?(actual_class.to_s)
-      end.compact
-    ]
-  end
-
-  def removed_classes_for environment
-    db_classes_name(environment) - actual_classes_name(environment)
-  end
-
-  def updated_classes_for environment
-    return [] unless db_environments.include?(environment) && actual_environments.include?(environment)
-    HashWithIndifferentAccess[
-      db_classes(environment).map do |db_class|
-        params = EnvironmentClass.all_parameters_for_class(db_class.id, find_or_create_env(environment).id).map(&:lookup_key)
-        compare_classes(environment, db_class.name, params)
-      end.compact
-    ]
-  end
-
-  # This method check if the puppet class exists in this environment, and compare the class params.
-  # Changes in the params are categorized to new parameters, removed parameters and parameters with a new
-  # default value.
-  def compare_classes(environment, klass, db_params)
-    return nil unless (actual_class = actual_classes(environment)[klass])
-    actual_params  = actual_class.parameters
-    db_param_names = db_params.map(&:to_s)
-
-    param_changes = { }
-    old           = db_param_names - actual_params.keys
-    param_changes['obsolete'] = old if old.any?
-    new = actual_params.reject { |key, value| db_param_names.include?(key) }
-    param_changes['new'] = new if new.any?
-    updated = updated_classes(actual_params, db_params)
-    param_changes['updated'] = updated if updated.any?
-    [klass, param_changes] if param_changes.keys.any?
-  end
-
-  def updated_classes(actual_params, db_params)
-    updated = { }
-    db_params.map do |p|
-      param_name = p.to_s
-      if !p.override && actual_params.has_key?(param_name) && actual_params[param_name] != p.default_value
-        updated[param_name] = actual_params[param_name]
-      end
-    end
-    updated
-  end
-
-
-  def db_environments
-    @foreman_envs ||= (Environment.all.map(&:name) - ignored_environments)
-  end
-
-  def actual_environments
-    @proxy_envs ||= (proxy.environments.map(&:to_s) - ignored_environments)
-  end
-
-  def new_environments
-    actual_environments - db_environments
-  end
-
-  def old_environments
-    db_environments - actual_environments
-  end
-
-  def db_classes environment
-    return @foreman_classes[environment] if @foreman_classes[environment]
-    return [] unless (env = Environment.find_by_name(environment))
-    @foreman_classes[environment] = env.puppetclasses.includes(:lookup_keys, :class_params)
-  end
-
-  def db_classes_name environment
-    db_classes(environment).map(&:name)
-  end
-
-  def actual_classes environment
-    @proxy_classes[environment] ||= proxy.classes(environment).reject do |key, value|
-      ignored_classes.find { |filter| filter.is_a?(Regexp) && filter =~ key }
-    end
-  end
-
-  def actual_classes_name environment
-    actual_classes(environment).keys
-  end
-
-  private
-  attr_reader :proxy
-
-  def ignored_environments
-    ignored_file[:ignored] || []
-  end
-
-  def ignored_classes
-    ignored_file[:filters] || []
-  end
-
-  def ignored_file
-    return @ignored_file if @ignored_file
-    file          = File.join(Rails.root.to_s, "config", "ignored_environments.yml")
-    @ignored_file = File.exist?(file) ? YAML.load_file(file) : { }
-  rescue => e
-    logger.warn "Failed to parse environment ignore file: #{e}"
-    @ignored_file = { }
-  end
-
-  def logger
-    @logger ||= Rails.logger
-  end
-
-  def load_classes_from_json blob
-    ActiveSupport::JSON.decode blob
-  end
-
-  def add_classes_to_foreman env_name, klasses
-    env         = find_or_create_env env_name
-    new_classes = klasses.map { |k| Puppetclass.find_or_create_by_name(k[0]) }
-
-    new_classes.each do |new_class|
-      EnvironmentClass.create! :puppetclass_id => new_class.id, :environment_id => env.id
-      class_params = klasses[new_class.to_s]
-      add_new_parameter(env, new_class, class_params) if class_params.any?
-    end
-  end
-
-  def update_classes_in_foreman environment, klasses
-    env        = find_or_create_env(environment)
-    db_classes = env.puppetclasses.where(:name => klasses.keys)
-    db_classes.each do |db_class|
-      changed_params = klasses[db_class.to_s]
-      # Add new parameters
-      add_new_parameter(env, db_class, changed_params) if changed_params["new"]
-      # Unbind old parameters
-      remove_parameter(env, db_class, changed_params) if changed_params["obsolete"]
-      # Update parameters (affects solely the default value)
-      update_parameter(db_class, changed_params) if changed_params["updated"]
-    end
-  end
-
-  def update_parameter(db_class, changed_params)
-    changed_params["updated"].each do |param_name, value|
-      key = db_class.class_params.find_by_key param_name
-      if key.override == false
-        key.default_value = value
-        key.save!
-      end
-    end
-  end
-
-  def remove_parameter(env, db_class, changed_params)
-    changed_params["obsolete"].each do |param_name, value|
-      key        = db_class.class_params.find_by_key param_name
-      key_in_env = EnvironmentClass.key_in_environment(env, db_class, key)
-
-      if key && key_in_env && !key.override?
-        #detach
-        key_in_env.destroy
-        # destroy if the key is not in any environment.
-        key.destroy unless EnvironmentClass.is_in_any_environment(db_class, key)
-      end
-    end
-  end
-
-  def add_new_parameter(env, klass, changed_params)
-    changed_params["new"].map do |param_name, value|
-      param = find_or_create_puppet_class_param klass, param_name, value
-      EnvironmentClass.create! :puppetclass_id => klass.id, :environment_id => env.id, :lookup_key_id => param.id
-    end
-  end
-
-  def remove_classes_from_foreman env_name, klasses
-    env     = find_or_create_env(env_name)
-    classes = find_existing_foreman_classes(klasses)
-    env.puppetclasses.delete classes
-    # remove all old classes from hosts
-    HostClass.joins(:host).where(:hosts => { :environment_id => env.id }, :puppetclass_id => classes).destroy_all
-    if klasses.include? '_destroy_'
-      # we can't guaranty that the env would be removed as it might have hosts attached to it.
-      env.destroy
-    end
-    # remove all klasses that have no environment now
-    classes.not_in_any_environment.destroy_all
-  end
-
-  def logger
-    @logger ||= Rails.logger
-  end
-
-  def find_existing_foreman_classes klasses = []
-    Puppetclass.where(:name => klasses)
-  end
-
-  def find_or_create_env env
-    Environment.where(:name => env).first || Environment.create!(:name => env)
-  end
-
-  def find_or_create_puppet_class_param klass, param_name, value
-    klass.class_params.where(:key => param_name).first ||
-      LookupKey.create!(:key            => param_name, :is_param => true,
-                        :required       => value.nil?, :override => value.nil?, :default_value => value,
-                        :key_type => Foreman::ImporterPuppetclass.suggest_key_type(value))
-  end
-
-end

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

@@ -1,172 +0,0 @@
-class Puppetclass < ActiveRecord::Base
-  include Authorization
-  has_many :environment_classes, :dependent => :destroy
-  has_many :environments, :through => :environment_classes, :uniq => true
-  has_and_belongs_to_many :operatingsystems
-  has_many :hostgroup_classes, :dependent => :destroy
-  has_many :hostgroups, :through => :hostgroup_classes
-  has_many :host_classes, :dependent => :destroy
-  has_many_hosts :through => :host_classes
-
-  has_many :lookup_keys, :inverse_of => :puppetclass
-  accepts_nested_attributes_for :lookup_keys, :reject_if => lambda { |a| a[:key].blank? }, :allow_destroy => true
-  # param classes
-  has_many :class_params, :through => :environment_classes, :uniq => true,
-    :source => :lookup_key, :conditions => 'environment_classes.lookup_key_id is NOT NULL'
-  accepts_nested_attributes_for :class_params, :reject_if => lambda { |a| a[:key].blank? }, :allow_destroy => true
-  validates_uniqueness_of :name
-  validates_presence_of :name
-  validates_format_of :name, :with => /\A(\S+\s?)+\Z/, :message => "can't be blank or contain white spaces."
-  audited
-
-  before_destroy EnsureNotUsedBy.new(:hosts)
-  before_destroy EnsureNotUsedBy.new(:hostgroups)
-  default_scope :order => 'puppetclasses.name'
-
-  scoped_search :on => :name, :complete_value => :true
-  scoped_search :in => :environments, :on => :name, :complete_value => :true, :rename => "environment"
-  scoped_search :in => :hostgroups,   :on => :name, :complete_value => :true, :rename => "hostgroup"
-  scoped_search :in => :hosts, :on => :name, :complete_value => :true, :rename => "host", :ext_method => :search_by_host, :only_explicit => true
-  scoped_search :in => :class_params, :on => :key, :complete_value => :true
-
-  scope :not_in_any_environment, includes(:environment_classes).where(:environment_classes => {:environment_id => nil})
-
-  def to_param
-    name
-  end
-
-  # returns a hash containing modules and associated classes
-  def self.classes2hash classes
-    hash = {}
-    for klass in classes
-      if (mod = klass.module_name)
-        hash[mod] ||= []
-        hash[mod] << klass
-      else
-        next
-      end
-    end
-    return hash
-  end
-
-  # returns module name (excluding of the class name)
-  # if class separator does not exists (the "::" chars), then returns the whole class name
-  def module_name
-    (i = name.index("::")) ? name[0..i-1] : name
-  end
-
-  # returns class name (excluding of the module name)
-  def klass
-    name.gsub(module_name+"::","")
-  end
-
-  # Populates the rdoc tree with information about all the classes in your modules.
-  #   Firstly, we prepare the modules tree
-  #   Secondly we run puppetdoc over the modulespath and manifestdir for all environments
-  # The results are written into document_root/puppet/rdoc/<env>/<class>"
-  def self.rdoc root
-    debug, verbose = false, false
-    relocated      = root != "/"             # This is true if the prepare phase copied the modules tree
-
-    # Retrieve an optional http server's DocumentRoot from the settings.yaml file, and prepare it for writing
-    doc_root = Pathname.new(Setting[:document_root])
-    doc_root.mkpath
-    unless doc_root.directory? and doc_root.writable?
-      puts "Unable to write html to #{doc_root}"
-      return false
-    end
-    validator = '<div id="validator-badges">'
-    # For each environment we write a puppetdoc tree
-    for env, path in Environment.puppetEnvs
-      # We may need to rewrite the modulepaths because they have been changed by the prepare step
-      modulepaths = relocated ? path.split(":").map{|p| root + p}.join(":") : path
-
-      # Identify and prepare the output directory
-      out = doc_root + env
-      out.rmtree if out.directory?
-
-      replacement = "<div id=\\\"validator-badges\\\"><small><a href=\\\"/puppet/rdoc/#{env}/\\\">[Browser]</a></small>"
-
-      # Create the documentation
-
-      puts "*********Proccessing environment #{env} *************"
-      cmd = "puppetdoc --output #{out} --modulepath #{modulepaths} -m rdoc"
-      puts cmd if defined?(Rake)
-      sh cmd do |ok, res|
-        if ok
-          # Add a link to the class browser
-          files =  %x{find #{out} -exec grep -l 'validator-badges' {} \\; 2>/dev/null}.gsub(/\n/, " ")
-          if files.empty?
-            warn "No files to update with the browser link in #{out}. This is probably due to a previous error."
-          else
-            cmd = "ruby -p -i -e '$_.gsub!(/#{validator}/,\"#{replacement}\")' #{files}"
-            puts cmd if debug
-           sh cmd
-          end
-          # Relocate the paths for files and references if the manifests were relocated and sanitized
-          if relocated and (files = %x{find #{out} -exec grep -l '#{root}' {} \\;}.gsub(/\n/, " ")) != ""
-            puts "Rewriting..." if verbose
-            cmd = "ruby -p -i -e 'rex=%r{#{root}};$_.gsub!(rex,\"\")' #{files}"
-            puts cmd if debug
-            sh cmd
-            # Now relocate the files/* files to match the rewritten url
-            mv Dir.glob("#{out}/files/#{root}/*"), "#{out}/files", :verbose => verbose
-          end
-        else
-          logger.warn "Failed to process puppetdocs for #{out} while executing #{cmd}"
-          puts "Failed to process puppetdocs for #{out} while executing #{cmd}"
-        end
-      end
-      puts
-    end
-  end
-
-  # Optionally creates a copy of the current puppet modules and sanitizes it.
-  # If your 'live' manifests and modules can be parsed by puppetdoc
-  # then you do not need to do this step. (Unfortunately some sites have circular
-  # symlinks which have to be removed.)
-  # If the executable Rails,root/script/rdoc_prepare_script exists then it is run
-  # and passed a list of all directory paths in all environments.
-  # It should return the directory into which it has copied the cleaned modules"
-  def self.prepare_rdoc root
-    debug, verbose = false, false
-
-    prepare_script = Pathname.new(Rails.root) + "script/rdoc_prepare_script.rb"
-    if prepare_script.executable?
-      dirs = Environment.puppetEnvs.values.join(":").split(":").uniq.sort.join(" ")
-      puts "Running #{prepare_script} #{dirs}" if debug
-      location = %x{#{prepare_script} #{dirs}}
-      if $? == 0
-        root = location.chomp
-        puts "Relocated modules to #{root}" if verbose
-      end
-    else
-      puts "No executable #{prepare_script} found so using the uncopied module sources" if verbose
-    end
-    root
-  end
-
-  def as_json(options={})
-    super({:only => [:name, :id], :include => [:lookup_keys]})
-  end
-
-  def self.search_by_host(key, operator, value)
-    conditions = sanitize_sql_for_conditions(["hosts.name #{operator} ?", value_to_sql(operator, value)])
-    direct     = Puppetclass.joins(:hosts).where(conditions).select('puppetclasses.id').map(&:id).uniq
-    hostgroup  = Hostgroup.joins(:hosts).where(conditions).first
-    indirect   = HostgroupClass.where(:hostgroup_id => hostgroup.path_ids).pluck(:puppetclass_id).uniq
-    return { :conditions => "1=0" } if direct.blank? && indirect.blank?
-
-    puppet_classes = (direct + indirect).uniq
-    { :conditions => "puppetclasses.id IN(#{puppet_classes.join(',')})" }
-  end
-
-
-  def self.value_to_sql(operator, value)
-    return value                 if operator !~ /LIKE/i
-    return value.tr_s('%*', '%') if (value ~ /%|\*/)
-
-    return "%#{value}%"
-  end
-
-end