katello 4.1.0.rc2.2 → 4.1.0

data/app/lib/actions/pulp/consumer/update.rb

@@ -1,20 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class Update < Pulp::Abstract
-        input_format do
-          param :uuid, String
-          param :display_name, String
-        end
-
-        def plan(system)
-          plan_self(:uuid => system.uuid, :display_name => system.name)
-        end
-
-        def run
-          ::Katello.pulp_server.extensions.consumer.update(input[:uuid], :display_name => input[:name])
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp3/capsule_content/refresh_content_guard.rb

@@ -1,17 +0,0 @@
-module Actions
-  module Pulp3
-    module CapsuleContent
-      class RefreshContentGuard < Pulp3::AbstractAsyncTask
-        def plan(smart_proxy, options = {})
-          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
-          content_guard_href = content_guard_api.list&.results&.first&.pulp_href
-          if content_guard_href && options.try(:[], :update)
-            content_guard_api.partial_update content_guard_href
-          else
-            content_guard_api.create
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/katello/events/import_host_applicability.rb

@@ -1,16 +0,0 @@
-module Katello
-  module Events
-    class ImportHostApplicability
-      EVENT_TYPE = 'import_host_applicability'.freeze
-
-      def initialize(object_id)
-        @host = ::Host.find_by_id(object_id)
-        Rails.logger.warn "Host not found for ID #{object_id}" if @host.nil?
-      end
-
-      def run
-        @host.content_facet.try(:import_applicability, true) if @host
-      end
-    end
-  end
-end

data/app/services/katello/applicable_content_helper.rb

@@ -1,111 +0,0 @@
-module Katello
-  class ApplicableContentHelper
-    attr_accessor :content_facet, :content_unit_class
-
-    def initialize(content_unit_class, content_facet = nil)
-      self.content_facet = content_facet
-      self.content_unit_class = content_unit_class
-    end
-
-    def import(partial)
-      to_add, to_remove = applicable_differences(partial)
-      content_facet_association_class.where(:content_facet_id => content_facet.id).delete_all unless partial
-      ActiveRecord::Base.transaction do
-        insert(to_add) unless to_add.blank?
-        remove(to_remove) unless to_remove.blank?
-      end
-    end
-
-    def installable(env = nil, content_view = nil)
-      repos = if env && content_view
-                Katello::Repository.in_environment(env).in_content_views([content_view])
-              else
-                content_facet.bound_repositories.pluck(:id)
-              end
-      content_facet.send(applicable_units).in_repositories(repos)
-    end
-
-    def installable_for_hosts(hosts = nil)
-      # Main goal of this query
-      # 1) Get me the applicable content units for these set of hosts
-      # 2) Now further prune this list. Only include units from repos that have been "enabled" on those hosts.
-      #    In other words, prune the list to only include the units in the "bound" repositories signified by
-      #    the inner join between ContentFacetRepository and Repository<Unit>
-
-      facet_repos = Katello::ContentFacetRepository.joins(:content_facet => :host).select(:repository_id)
-      facet_content_units = content_facet_association_class.joins(:content_facet => :host).select(content_unit_association_id)
-
-      if hosts
-        hosts = ::Host.where(id: hosts) if hosts.is_a?(Array)
-        facet_repos = facet_repos.merge(hosts).reorder(nil)
-        facet_content_units = facet_content_units.merge(hosts).reorder(nil)
-      end
-
-      content_unit_class.joins(repository_association_units).
-                         where(repository_association_class.table_name => {:repository_id => facet_repos,
-                                                                           content_unit_association_id => facet_content_units}).distinct
-    end
-
-    private
-
-    def content_units
-      content_unit_class.name.demodulize.pluralize.underscore.to_sym
-    end
-
-    def applicable_units
-      "applicable_#{content_units}".to_sym
-    end
-
-    def content_unit_association_id
-      "#{content_unit_class.name.demodulize.underscore}_id".to_sym
-    end
-
-    def content_type
-      content_unit_class.const_get(:CONTENT_TYPE)
-    end
-
-    def content_facet_association_class
-      # Example: ContentFacetErratum
-      self.content_unit_class.content_facet_association_class
-    end
-
-    def content_facet_association_units
-      content_facet_association_class.name.demodulize.pluralize.underscore.to_sym
-    end
-
-    def repository_association_class
-      content_unit_class.repository_association_class
-    end
-
-    def repository_association_units
-      repository_association_class.name.demodulize.pluralize.underscore.to_sym
-    end
-
-    def applicable_differences(partial)
-      content_uuids = ::Katello::Pulp::Consumer.new(content_facet.uuid).applicable_ids(content_type)
-      if partial
-        consumer_uuids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.pulp_id")
-        to_remove = consumer_uuids - content_uuids
-        to_add = content_uuids - consumer_uuids
-      else
-        to_add = content_uuids
-        to_remove = nil
-      end
-      [to_add, to_remove]
-    end
-
-    def insert(pulp_ids)
-      applicable_ids = content_unit_class.where(:pulp_id => pulp_ids).pluck(:id)
-      unless applicable_ids.empty?
-        inserts = applicable_ids.map { |applicable_id| "(#{applicable_id.to_i}, #{content_facet.id.to_i})" }
-        sql = "INSERT INTO #{content_facet_association_class.table_name} (#{content_unit_association_id}, content_facet_id) VALUES #{inserts.join(', ')}"
-        ActiveRecord::Base.connection.execute(sql)
-      end
-    end
-
-    def remove(pulp_ids)
-      applicable_ids = content_unit_class.where(:pulp_id => pulp_ids).pluck(:id)
-      content_facet_association_class.where(:content_facet_id => content_facet.id, content_unit_association_id => applicable_ids).delete_all
-    end
-  end
-end

data/app/services/katello/pulp/consumer.rb

@@ -1,83 +0,0 @@
-module Katello
-  module Pulp
-    class Consumer
-      include LazyAccessor
-
-      attr_accessor :uuid
-
-      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)
-
-      def initialize(uuid)
-        self.uuid = uuid
-      end
-
-      def upload_package_profile(profile)
-        Katello.pulp_server.extensions.consumer.upload_profile(self.uuid, 'rpm', profile)
-      end
-
-      def upload_module_stream_profile(profile)
-        Katello.pulp_server.extensions.consumer.upload_profile(self.uuid, 'modulemd', profile)
-      end
-
-      def applicable_ids(content_unit_type)
-        consumer_method = case content_unit_type
-                          when ::Katello::Erratum::CONTENT_TYPE
-                            :applicable_errata
-                          when ::Katello::ModuleStream::CONTENT_TYPE
-                            :applicable_module_streams
-                          else
-                            :applicable_rpms
-                          end
-        response = Katello.pulp_server.extensions.consumer.send(consumer_method, [self.uuid])
-        return [] if response.empty?
-        response[0]['applicability'][content_unit_type] || []
-      end
-
-      def bind_yum_repositories(ids)
-        bind_repos(Runcible::Models::YumDistributor.type_id, bound_yum_repositories, ids, :notify_agent => false)
-      end
-
-      def bound_yum_repositories
-        bindings(Runcible::Models::YumDistributor.type_id)
-      end
-
-      private
-
-      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 bind_repos(distributor_type, existing_ids, update_ids, bind_options = {})
-        bound_ids     = existing_ids
-        intersection  = update_ids & bound_ids
-        bind_ids      = update_ids - intersection
-        unbind_ids    = bound_ids - intersection
-
-        unbind_repo_ids(unbind_ids, distributor_type)
-        bind_repo_ids(bind_ids, distributor_type, bind_options)
-      end
-
-      def unbind_repo_ids(repo_ids, distributor_type)
-        repo_ids.each do |repo_id|
-          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")}"
-        end
-      end
-
-      def bind_repo_ids(repo_ids, distributor_type, bind_options)
-        repo_ids.each do |repo_id|
-          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")}"
-        end
-      end
-    end
-  end
-end

data/app/services/katello/pulp/consumer_group.rb

@@ -1,95 +0,0 @@
-module Katello
-  module Pulp
-    class ConsumerGroup
-      attr_accessor :pulp_id, :consumer_ids
-
-      def set_pulp_consumer_group
-        Rails.logger.debug "creating pulp consumer group '#{self.pulp_id}'"
-        Katello.pulp_server.extensions.consumer_group.create(self.pulp_id, :consumer_ids => (consumer_ids || []))
-      rescue => e
-        Rails.logger.error "Failed to create pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def del_pulp_consumer_group
-        Rails.logger.debug "deleting pulp consumer group '#{self.pulp_id}'"
-        Katello.pulp_server.extensions.consumer_group.delete(self.pulp_id)
-      rescue => e
-        Rails.logger.error "Failed to delete pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_package(packages)
-        Rails.logger.debug "Scheduling package install for consumer group #{self.pulp_id}"
-
-        Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
-                                                                        'rpm',
-                                                                        packages,
-                                                                        'importkeys' => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule package install for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def uninstall_package(packages)
-        Rails.logger.debug "Scheduling package uninstall for consumer group #{self.pulp_id}"
-
-        Katello.pulp_server.extensions.consumer_group.uninstall_content(self.pulp_id,
-                                                                          'rpm',
-                                                                          packages)
-      rescue => e
-        Rails.logger.error "Failed to schedule package uninstall for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def update_package(packages, options = {})
-        Rails.logger.debug "Scheduling package update for consumer group #{self.pulp_id}"
-
-        options.merge!(:importkeys => true)
-        options[:all] = true if options[:update_all]
-        Katello.pulp_server.extensions.consumer_group.update_content(self.pulp_id,
-                                                                       'rpm',
-                                                                       packages,
-                                                                       options)
-      rescue => e
-        Rails.logger.error "Failed to schedule package update for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_package_group(groups)
-        Rails.logger.debug "Scheduling package group install for consumer group #{self.pulp_id}"
-
-        Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
-                                                                        'package_group',
-                                                                        groups,
-                                                                        'importkeys' => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule package group install for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def uninstall_package_group(groups)
-        Rails.logger.debug "Scheduling package group uninstall for consumer group #{self.pulp_id}"
-
-        Katello.pulp_server.extensions.consumer_group.uninstall_content(self.pulp_id,
-                                                                          'package_group',
-                                                                          groups)
-      rescue => e
-        Rails.logger.error "Failed to schedule package group uninstall for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-
-      def install_consumer_errata(errata_ids)
-        Rails.logger.debug "Scheduling errata install for consumer group #{self.pulp_id}"
-
-        Katello.pulp_server.extensions.consumer_group.install_content(self.pulp_id,
-                                                                        'erratum',
-                                                                        errata_ids,
-                                                                        'importkeys' => true)
-      rescue => e
-        Rails.logger.error "Failed to schedule errata install for pulp consumer group #{self.pulp_id}: #{e}, #{e.backtrace.join("\n")}"
-        raise e
-      end
-    end
-  end
-end