katello 3.1.0.1 → 3.2.0.rc1

data/app/models/katello/glue/pulp/consumer.rb

@@ -1,171 +0,0 @@
-module Katello
-  module Glue::Pulp::Consumer
-    def self.included(base)
-      base.send :include, InstanceMethods
-      base.send :include, LazyAccessor
-
-      base.class_eval do
-        lazy_accessor :pulp_facts, :initializer => lambda { |_s| Katello.pulp_server.extensions.consumer.retrieve(uuid) }
-        lazy_accessor :package_profile, :initializer => lambda { |_s| fetch_package_profile }
-        lazy_accessor :simple_packages, :initializer => (lambda do |_s|
-                                                           fetch_package_profile["profile"].
-                                                             collect { |package| Katello::Pulp::SimplePackage.new(package) }
-                                                         end)
-      end
-    end
-
-    module InstanceMethods
-      def bound_node_repos
-        bindings(Runcible::Models::NodesHttpDistributor.type_id)
-      end
-
-      def bindings(type_id)
-        bindings = Katello.pulp_server.extensions.consumer.retrieve_bindings(uuid)
-        bindings.select { |b| b['type_id'] == type_id }.collect { |repo| repo["repo_id"] }
-      end
-
-      def enable_node_repos(repo_ids)
-        enable_repos(Runcible::Models::NodesHttpDistributor.type_id, bound_node_repos, repo_ids,
-                     :notify_agent => false, :binding_config => {:strategy => 'mirror'})
-      end
-
-      def pulp_bound_yum_repositories
-        bindings(Runcible::Models::YumDistributor.type_id)
-      end
-
-      # Binds and unbinds distributors of a certain type across repos
-      def enable_repos(distributor_type, existing_ids, update_ids, bind_options = {})
-        # calculate repoids to bind/unbind
-        bound_ids     = existing_ids
-        intersection  = update_ids & bound_ids
-        bind_ids      = update_ids - intersection
-        unbind_ids    = bound_ids - intersection
-
-        Rails.logger.debug "Bound repo ids: #{bound_ids.inspect}"
-        Rails.logger.debug "Update repo ids: #{update_ids.inspect}"
-        Rails.logger.debug "Repo ids to bind: #{bind_ids.inspect}"
-        Rails.logger.debug "Repo ids to unbind: #{unbind_ids.inspect}"
-
-        error_ids = unbind_repo_ids(unbind_ids, distributor_type)
-        error_ids += bind_repo_ids(bind_ids, distributor_type, bind_options)
-        error_ids
-      end
-
-      def unbind_repo_ids(repo_ids, distributor_type)
-        error_ids = []
-
-        repo_ids.each do |repo_id|
-          begin
-            Katello.pulp_server.extensions.consumer.unbind_all(uuid, repo_id, distributor_type)
-          rescue => e
-            Rails.logger.error "Failed to unbind repo #{repo_id}: #{e}, #{e.backtrace.join("\n")}"
-            error_ids << repo_id
-          end
-        end
-        error_ids
-      end
-
-      def bind_repo_ids(repo_ids, distributor_type, bind_options)
-        error_ids = []
-
-        repo_ids.each do |repo_id|
-          begin
-            Katello.pulp_server.extensions.consumer.bind_all(uuid, repo_id, distributor_type, bind_options)
-          rescue => e
-            Rails.logger.error "Failed to bind repo #{repo_id}: #{e}, #{e.backtrace.join("\n")}"
-            error_ids << repo_id
-          end
-        end
-        error_ids
-      end
-
-      def pulp_errata_uuids
-        response = Katello.pulp_server.extensions.consumer.applicable_errata([self.uuid])
-        return [] if response.empty?
-        response[0]['applicability']['erratum'] || []
-      end
-
-      def del_pulp_consumer
-        Rails.logger.debug "Deleting consumer in pulp: #{self.name}"
-        Katello.pulp_server.extensions.consumer.delete(self.uuid)
-      rescue => e
-        Rails.logger.error "Failed to delete pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def update_pulp_consumer
-        return true if @changed_attributes.empty?
-
-        Rails.logger.debug "Updating consumer in pulp: #{self.name}"
-        Katello.pulp_server.extensions.consumer.update(self.uuid, :display_name => self.name)
-      rescue => e
-        Rails.logger.error "Failed to update pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_package(packages)
-        Rails.logger.debug "Scheduling package install for consumer #{self.name}"
-        Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'rpm', packages, "importkeys" => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule package install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def uninstall_package(packages)
-        Rails.logger.debug "Scheduling package uninstall for consumer #{self.name}"
-        Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'rpm', packages)
-      rescue => e
-        Rails.logger.error "Failed to schedule package uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def update_package(packages)
-        Rails.logger.debug "Scheduling package update for consumer #{self.name}"
-        options = {"importkeys" => true}
-        options[:all] = true if packages.blank?
-        Katello.pulp_server.extensions.consumer.update_content(self.uuid, 'rpm', packages, options)
-      rescue => e
-        Rails.logger.error "Failed to schedule package update for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_package_group(groups)
-        Rails.logger.debug "Scheduling package group install for consumer #{self.name}"
-        Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'package_group', groups, "importkeys" => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule package group install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def uninstall_package_group(groups)
-        Rails.logger.debug "Scheduling package group uninstall for consumer #{self.name}"
-        Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'package_group', groups)
-      rescue => e
-        Rails.logger.error "Failed to schedule package group uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_consumer_errata(errata_ids)
-        Rails.logger.debug "Scheduling errata install for consumer #{self.name}"
-        Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'erratum', errata_ids, "importkeys" => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule errata install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def katello_agent_installed?
-        return false if self.is_a? Hypervisor
-        simple_packages.any? { |package| package.name == "katello-agent" }
-      end
-
-      private
-
-      def fetch_package_profile
-        Katello.pulp_server.extensions.consumer.retrieve_profile(uuid, 'rpm')
-      rescue RestClient::ResourceNotFound => e
-        Rails.logger.info "Failed to find profile for #{uuid}: #{e}}"
-        {:profile => []}.with_indifferent_access
-      end
-    end
-  end
-end

data/app/models/katello/hypervisor.rb

@@ -1,15 +0,0 @@
-module Katello
-  class Hypervisor < System
-    validates_lengths_from_database
-
-    UNSUPPORTED_ACTIONS = [:package_profile, :pulp_facts, :simple_packages, :errata, :del_pulp_consumer, :set_pulp_consumer,
-                           :update_pulp_consumer, :upload_package_profile, :install_package, :uninstall_package,
-                           :update_package, :install_package_group, :uninstall_package_group].freeze
-
-    UNSUPPORTED_ACTIONS.each do |unsupported_action|
-      define_method(unsupported_action) do
-        fail Errors::UnsupportedActionException.new(unsupported_action, self, _("Hypervisor does not support this action"))
-      end
-    end
-  end
-end

data/app/models/katello/system.rb

@@ -1,283 +0,0 @@
-module Katello
-  class System < Katello::Model
-    self.include_root_in_json = false
-
-    include ForemanTasks::Concerns::ActionSubject
-    include Glue::Candlepin::Consumer if SETTINGS[:katello][:use_cp]
-    include Glue::Pulp::Consumer if SETTINGS[:katello][:use_pulp]
-    include Glue if SETTINGS[:katello][:use_cp] || SETTINGS[:katello][:use_pulp]
-    include Authorization::System
-
-    audited :on => [:create], :allow_mass_assignment => true
-
-    belongs_to :environment, :class_name => "Katello::KTEnvironment", :inverse_of => :systems
-    belongs_to :foreman_host, :class_name => "::Host::Managed", :foreign_key => :host_id, :inverse_of => :content_host
-
-    has_many :bound_repositories, :through => :system_repositories, :class_name => "Katello::Repository", :source => :repository
-    has_many :system_repositories, :class_name => "Katello::SystemRepository", :dependent => :destroy, :inverse_of => :system
-
-    has_many :task_statuses, :class_name => "Katello::TaskStatus", :as => :task_owner, :dependent => :destroy
-    has_many :system_activation_keys, :class_name => "Katello::SystemActivationKey", :dependent => :destroy
-    has_many :activation_keys, :through => :system_activation_keys
-
-    has_many :host_collection_hosts, :through => :foreman_host, :class_name => "::Katello::HostCollectionHosts",
-             :foreign_key => :host_id
-    has_many :host_collections, :through => :host_collection_hosts, :foreign_key => :host_id
-
-    has_many :audits, :class_name => "::Audit", :as => :auditable, :dependent => :destroy
-
-    belongs_to :content_view, :inverse_of => :systems
-
-    validates_lengths_from_database
-    before_validation :set_default_content_view, :unless => :persisted?
-    validates :environment, :presence => true
-    validates :content_view, :presence => true, :allow_blank => false
-    validates_with Validators::NoTrailingSpaceValidator, :attributes => :name
-    validates :location, :length => {:maximum => 255}
-    validates_with Validators::ContentViewEnvironmentValidator
-    validates_with Validators::KatelloNameFormatValidator, :attributes => :name
-
-    before_create :fill_defaults
-
-    scope :in_environment, ->(env) { where('environment_id = ?', env) unless env.nil? }
-    scope :by_uuids, ->(uuids) { where(:uuid => uuids) }
-
-    scoped_search :on => :name, :complete_value => true
-    scoped_search :in => :activation_keys, :on => :name, :complete_value => true, :rename => :activation_key
-    scoped_search :in => :content_view, :on => :name, :complete_value => true, :rename => :content_view
-    scoped_search :in => :fact_values, :on => :value, :in_key => :fact_names, :on_key => :name, :rename => :facts, :complete_value => true,
-                  :only_explicit => true, :ext_method => :search_cast_facts
-    scoped_search :in => :foreman_host, :on => :name, :complete_value => true, :rename => :host
-    scoped_search :in => :environment, :on => :name, :complete_value => true, :rename => :environment
-    # scoped_search :in => :host_collections, :on => :name, :rename => :host_collection, :complete_value => true,
-    #               :ext_method => :search_host_collections
-    scoped_search :in => :host_collections, :on => :name, :rename => :host_collection, :complete_value => true
-    has_many :fact_values, :through => :foreman_host
-    has_many :fact_names, :through => :fact_values
-
-    def self.in_organization(organization)
-      where(:environment_id => organization.kt_environments.pluck(:id))
-    end
-
-    def self.uuids_to_ids(uuids)
-      systems = by_uuids(uuids)
-      ids_not_found = Set.new(uuids).subtract(systems.pluck(:uuid))
-      fail Errors::NotFound, _("Systems [%s] not found.") % ids_not_found.to_a.join(',') unless ids_not_found.blank?
-      systems.pluck(:id)
-    end
-
-    def registered_by
-      audits.first.try(:username) unless activation_keys.length > 0
-    end
-
-    class << self
-      def architectures
-        { 'i386' => 'x86', 'ia64' => 'Itanium', 'x86_64' => 'x86_64', 'ppc' => 'PowerPC',
-          's390' => 'IBM S/390', 's390x' => 'IBM System z', 'sparc64' => 'SPARC Solaris',
-          'i686' => 'i686'}
-      end
-
-      def virtualized
-        { "physical" => N_("Physical"), "virtualized" => N_("Virtual") }
-      end
-    end
-
-    delegate :organization, to: :environment
-
-    def consumed_pool_ids
-      self.pools.collect { |t| t['id'] }
-    end
-
-    def available_releases
-      self.content_view.version(self.environment).available_releases
-    end
-
-    def consumed_pool_ids=(attributes)
-      attribs_to_unsub = consumed_pool_ids - attributes
-      attribs_to_unsub.each do |id|
-        self.unsubscribe id
-      end
-
-      attribs_to_sub = attributes - consumed_pool_ids
-      attribs_to_sub.each do |id|
-        self.subscribe id
-      end
-    end
-
-    def save_bound_repos_by_path!(paths)
-      repos = []
-      paths.each do |path|
-        possible_repos = Repository.where(:relative_path => path.gsub('/pulp/repos/', ''))
-        if possible_repos.empty?
-          Rails.logger.warn("System #{self.name} (#{self.id}) requested binding to unknown repo #{path}")
-        else
-          repos << possible_repos.first
-          Rails.logger.warn("System #{self.name} (#{self.id}) requested binding to path #{path} matching \
-                            #{possible_repos.size} repositories.") if possible_repos.size > 1
-        end
-      end
-
-      self.bound_repositories = repos
-      self.save!
-    end
-
-    def install_packages(packages)
-      pulp_task = self.install_package(packages)
-      save_task_status(pulp_task, :package_install, :packages, packages)
-    end
-
-    def uninstall_packages(packages)
-      pulp_task = self.uninstall_package(packages)
-      save_task_status(pulp_task, :package_remove, :packages, packages)
-    end
-
-    def update_packages(packages = nil)
-      # if no packages are provided, a full system update will be performed (e.g ''yum update' equivalent)
-      pulp_task = self.update_package(packages)
-      save_task_status(pulp_task, :package_update, :packages, packages)
-    end
-
-    def install_package_groups(groups)
-      pulp_task = self.install_package_group(groups)
-      save_task_status(pulp_task, :package_group_install, :groups, groups)
-    end
-
-    def uninstall_package_groups(groups)
-      pulp_task = self.uninstall_package_group(groups)
-      save_task_status(pulp_task, :package_group_remove, :groups, groups)
-    end
-
-    def as_json(options)
-      json = super(options)
-      json['environment'] = environment.as_json unless environment.nil?
-      json['activation_key'] = activation_keys.as_json unless activation_keys.nil?
-
-      json['content_view'] = content_view.as_json if content_view
-      json['ipv4_address'] = facts.try(:[], 'network.ipv4_address') if respond_to?(:facts)
-
-      if respond_to?(:virtual_guest)
-        if self.virtual_guest == 'true'
-          json['virtual_host'] = self.virtual_host.attributes if self.virtual_host
-        else
-          json['virtual_guests'] = self.virtual_guests.map(&:attributes)
-        end
-      end
-
-      if options[:expanded]
-        json['editable'] = editable?
-        json['type'] = type
-      end
-
-      json
-    end
-
-    def hypervisor?
-      self.is_a? Hypervisor
-    end
-
-    def system_type
-      if respond_to?(:virtual_guest) && virtual_guest
-        _("Virtual Guest")
-      else
-        case self
-        when Hypervisor
-          _("Hypervisor")
-        else
-          _("Host")
-        end
-      end
-    end
-
-    def refresh_tasks
-      refresh_running_tasks
-      import_candlepin_tasks
-    end
-
-    def tasks
-      refresh_tasks
-      self.task_statuses
-    end
-
-    def reportable_data(options = {})
-      hash = self.as_json(options.slice(:only, :except))
-      if options[:methods]
-        options[:methods].each { |method| hash[method] = self.send(method) }
-      end
-      hash.with_indifferent_access
-    end
-
-    def self.available_locks
-      [:read, :write]
-    end
-
-    def related_resources
-      self.organization
-    end
-
-    def to_action_input
-      super.merge(uuid => uuid)
-    end
-
-    def available_content
-      self.products.flat_map(&:available_content)
-    end
-
-    def self.search_host_collections(_key, operator, value)
-      conditions = sanitize_sql_for_conditions(["#{Katello::HostCollection.table_name}.name #{operator} '#{value}'"])
-      systems_matching_query = Katello::System.joins("INNER JOIN #{Katello::HostCollectionHosts.table_name} ON \
-        (#{Katello::HostCollectionHosts.table_name}.host_id = #{Katello::System.table_name}.host_id)").
-          joins("INNER JOIN #{Katello::HostCollection.table_name} ON \
-        (#{Katello::HostCollectionHosts.table_name}.host_collection_id = #{Katello::HostCollection.table_name}.id)").
-          where(conditions).select("id").to_sql
-      { :conditions => "#{Katello::System.table_name}.id in (#{systems_matching_query})", :include => :host_collections }
-    end
-
-    def self.search_cast_facts(key, operator, value)
-      {
-        :conditions => "fact_names.name = '#{key.split('.')[1]}' AND #{cast_facts(key, operator, value)}",
-        :include    => :fact_names
-      }
-    end
-
-    def self.cast_facts(_key, operator, value)
-      is_int = (value =~ /\A[-+]?\d+\z/) || value.is_a?(Integer)
-      is_pg = ActiveRecord::Base.connection.adapter_name.downcase.starts_with? 'postgresql'
-      # Once Postgresql 8 support is removed (used in CentOS 6), this could be replaced to only keep the first form (working well with PG 9)
-      if (is_int && !is_pg)
-        casted = "CAST(fact_values.value AS DECIMAL) #{operator} #{value}"
-      elsif (is_int && is_pg && operator !~ /LIKE/i)
-        casted = "fact_values.value ~ E'^\\\\d+$' AND CAST(fact_values.value AS DECIMAL) #{operator} #{value}"
-      else
-        casted = "fact_values.value #{operator} '#{value}'"
-      end
-      casted
-    end
-
-    def self.humanize_class_name(_name = nil)
-      _('Content Host')
-    end
-
-    private
-
-    def refresh_running_tasks
-      ids = self.task_statuses.where(:state => [:waiting, :running]).pluck(:id)
-      TaskStatus.refresh(ids)
-    end
-
-    def save_task_status(pulp_task, task_type, parameters_type, parameters)
-      TaskStatus.make(self, pulp_task, task_type, parameters_type => parameters)
-    end
-
-    def fill_defaults
-      self.location = _("None") unless self.location
-    end
-
-    def set_default_content_view
-      self.content_view = self.environment.try(:default_content_view) unless self.content_view
-    end
-
-    def collect_installed_product_names
-      self.installedProducts ? self.installedProducts.map { |p| p[:productName] } : []
-    end
-  end
-end