katello 4.7.6 → 4.8.0.rc1

data/app/lib/actions/pulp/repository/presenters/yum_presenter.rb

@@ -1,131 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      module Presenters
-        class YumPresenter < AbstractSyncPresenter
-          def progress
-            if sync_task && size_total > 0
-              size_done.to_f / size_total
-            else
-              0.01
-            end
-          end
-
-          private
-
-          def humanized_details
-            ret = []
-            ret << _("Cancelled.") if cancelled?
-
-            if pending?
-              ret << _("Pending")
-            elsif content_started?
-              if items_total > 0
-                ret << (_("New packages: %{count} (%{size}).") % {:count => count_summary, :size => size_summary})
-              else
-                #if there are no new packages, it could just mean that they have not started downloading yet
-                # so only tell the user no new packages if errata have been processed
-                if errata_details && errata_details['state'] != 'NOT_STARTED'
-                  ret << _("No new packages.")
-                else
-                  ret << _("Processing metadata.")
-                end
-              end
-            elsif metadata_in_progress?
-              ret << _("Processing metadata")
-            end
-
-            ret << _('Yum Metadata: %s') % metadata_error if metadata_error
-
-            if error_details.any?
-              ret << n_("Failed to download %s package.", "Failed to download %s packages.",
-                        error_details.count) % error_details.count
-            end
-            ret.join("\n")
-          end
-
-          def count_summary
-            if content_details[:state] == "IN_PROGRESS"
-              "#{items_done}/#{items_total}"
-            else
-              items_done
-            end
-          end
-
-          def size_summary
-            helper = Object.new.extend(ActionView::Helpers::NumberHelper)
-            if content_details[:state] == "IN_PROGRESS"
-              "#{helper.number_to_human_size(size_done)}/#{helper.number_to_human_size(size_total)}"
-            else
-              helper.number_to_human_size(size_total)
-            end
-          end
-
-          def task_progress
-            sync_task[:progress_report]
-          end
-
-          def task_progress_details
-            task_progress && task_progress[:yum_importer]
-          end
-
-          def task_details
-            task_result_details || task_progress_details
-          end
-
-          def content_details
-            task_details && task_details[:content]
-          end
-
-          def error_details
-            content_details.nil? ? [] : content_details[:error_details]
-          end
-
-          def metadata_details
-            task_details && task_details[:metadata]
-          end
-
-          def errata_details
-            task_details && task_details[:errata]
-          end
-
-          def items_done
-            items_total - content_details[:items_left]
-          end
-
-          def items_total
-            content_details[:items_total].to_i
-          end
-
-          def size_done
-            size_total - content_details[:size_left]
-          end
-
-          def size_total
-            (content_details && content_details[:size_total]).to_i
-          end
-
-          def cancelled?
-            task_details.nil? ? false : task_details.values.map { |item| item['state'] }.include?('CANCELLED')
-          end
-
-          def content_started?
-            content_details && content_details[:state] != 'NOT_STARTED'
-          end
-
-          def metadata_in_progress?
-            metadata_details && metadata_details[:state] == 'IN_PROGRESS'
-          end
-
-          def metadata_error
-            metadata_details && metadata_details[:error]
-          end
-
-          def pending?
-            metadata_details.nil? || metadata_details['state'] == 'NOT_RUNNING'
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/refresh.rb

@@ -1,21 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Refresh < Pulp::AbstractAsyncTask
-        def plan(repository, options = {})
-          options[:capsule_id] ||= SmartProxy.default_capsule!.id
-          plan_self(:capsule_id => options[:capsule_id], :pulp_id => repository.pulp_id)
-        end
-
-        def invoke_external_task
-          repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
-          if repo.nil?
-            repo = ::Katello::ContentViewPuppetEnvironment.find_by(:pulp_id => input[:pulp_id])
-            repo = repo.nonpersisted_repository
-          end
-          repo.backend_service(smart_proxy(input[:capsule_id])).refresh_if_needed
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/regenerate_applicability.rb

@@ -1,21 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class RegenerateApplicability < Pulp::AbstractAsyncTaskGroup
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
-
-        input_format do
-          param :repository_id
-          param :capsule_id
-          param :contents_changed
-        end
-
-        def invoke_external_task
-          capsule_id = input[:capsule_id] || SmartProxy.default_capsule!.id
-          repo = ::Katello::Repository.find(input[:repository_id])
-          repo.backend_service(smart_proxy(capsule_id)).regenerate_applicability
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/remove_distribution.rb

@@ -1,11 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class RemoveDistribution < Pulp::Repository::AbstractRemoveContent
-        def content_extension
-          pulp_extensions.distribution
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/remove_units.rb

@@ -1,44 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class RemoveUnits < Pulp::AbstractAsyncTask
-        input_format do
-          param :repo_id
-          param :content_view_puppet_environment_id
-          param :contents
-          param :content_unit_type
-        end
-
-        def invoke_external_task
-          fail _("Cannot pass content units without content unit type") if (input[:contents] && !input[:content_unit_type])
-          if input[:repo_id]
-            repo = ::Katello::Repository.find(input[:repo_id])
-          else
-            repo = ::Katello::ContentViewPuppetEnvironment.find(input[:content_view_puppet_environment_id]).nonpersisted_repository
-          end
-          fail _("An error occurred during content removal. Could not find repository with id: %s" % input[:repo_id]) unless repo
-          tasks = []
-          if input[:content_unit_type]
-            content_type = ::Katello::RepositoryTypeManager.find_content_type(input[:content_unit_type].downcase)
-            if input[:contents]
-              units = content_type.model_class.where(:id => input[:contents])
-              unit_pulp_ids = units.map(&:pulp_id).sort
-            end
-            tasks << ::SmartProxy.pulp_primary.content_service(content_type).remove(repo, unit_pulp_ids)
-          else
-            repo_content_types = ::Katello::RepositoryTypeManager.find(repo.content_type).content_types
-            repo_content_types.each do |type|
-              tasks << ::SmartProxy.pulp_primary.content_service(type).remove(repo)
-            end
-          end
-          tasks
-        end
-
-        def external_task=(external_task_data)
-          external_task_data = [external_task_data] if external_task_data.is_a?(Hash)
-          super(external_task_data.map { |task| task.except('result') })
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/sync.rb

@@ -1,99 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Sync < Pulp::AbstractAsyncTask
-        include Helpers::Presenter
-
-        input_format do
-          param :repo_id
-          param :source_url # allow overriding the feed URL
-          param :options # Pulp sync options
-        end
-
-        def invoke_external_task
-          overrides = {}
-          overrides[:feed] = input[:source_url] if input[:source_url]
-          overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-          overrides.merge(input[:options]) if input[:options]
-          repo = ::Katello::Repository.find(input[:repo_id])
-
-          output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_primary).sync(overrides)
-        end
-
-        def finalize
-          check_error_details
-        end
-
-        def external_task=(tasks)
-          output[:contents_changed] = contents_changed?(tasks)
-          super
-        end
-
-        def check_error_details
-          output[:pulp_tasks].each do |pulp_task|
-            error_details = pulp_task.try(:[], "progress_report").try(:[], "yum_importer").try(:[], "content").try(:[], "error_details")
-            if error_details && error_details[0]
-              fail _("An error occurred during the sync \n%{error_message}") % {:error_message => error_details[0]}
-            end
-          end
-        end
-
-        def contents_changed?(tasks)
-          if tasks.is_a?(Hash)
-            # note: for syncs initiated by a sync plan, tasks is a hash input
-            sync_task = tasks
-          else
-            sync_task = tasks.find { |task| (task['tags'] || []).include?('pulp:action:sync') }
-          end
-
-          if sync_task && sync_task['state'] == 'finished' && sync_task[:result]
-            if sync_task['result']['added_count'] > 0 || sync_task['result']['removed_count'] > 0 || sync_task['result']['updated_count'] > 0
-              true
-            else
-              repo = ::Katello::Repository.find_by(:pulp_id => sync_task['result']['repo_id'])
-              repo ? repo.pulp_counts_differ? : true
-            end
-          else
-            true #if we can't figure it out, assume something changed
-          end
-        end
-
-        def run_progress
-          presenter.progress
-        end
-
-        def run_progress_weight
-          10
-        end
-
-        def presenter
-          repo = ::Katello::Repository.find(input['repo_id']) if input['repo_id']
-          # For repo sync tasks older than katello 3.14, we only have pulp_id available in input.
-          repo ||= ::Katello::Repository.where(:pulp_id => input['pulp_id']).first if input['pulp_id']
-
-          if repo.try(:yum?)
-            Presenters::YumPresenter.new(self)
-          elsif repo.try(:file?)
-            Presenters::FileUnitPresenter.new(self)
-          elsif repo.try(:docker?)
-            Presenters::DockerPresenter.new(self)
-          elsif repo.try(:deb?)
-            Presenters::DebPresenter.new(self)
-          end
-        end
-
-        def rescue_strategy_for_self
-          # There are various reasons the syncing fails, not all of them are
-          # fatal: when fail on syncing, we continue with the task ending up
-          # in the warning state, but not locking further syncs
-          Dynflow::Action::Rescue::Skip
-        end
-
-        def ignored_tags
-          # ignore background download tasks
-          ["pulp:action:download"]
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/upload_file.rb

@@ -1,28 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class UploadFile < Pulp::Abstract
-        input_format do
-          param :upload_id
-          param :file
-        end
-
-        def run
-          File.open(input[:file], "rb") do |file|
-            offset = 0
-            while (chunk = file.read(upload_chunk_size))
-              pulp_resources.content.upload_bits(input[:upload_id], offset, chunk)
-              offset += upload_chunk_size
-            end
-          end
-        end
-
-        private
-
-        def upload_chunk_size
-          SETTINGS[:katello][:pulp][:upload_chunk_size]
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository_group/create.rb

@@ -1,31 +0,0 @@
-module Actions
-  module Pulp
-    module RepositoryGroup
-      class Create < Pulp::Abstract
-        include Helpers::Presenter
-
-        input_format do
-          param :id
-          param :pulp_ids
-        end
-
-        def run
-          pulp_resources.
-            repository_group.create(input[:id],
-                                    :id => input[:id],
-                                    :repo_ids => input[:pulp_ids],
-                                    :display_name => "temporary group for export",
-                                    :distributors => [group_export_distributor])
-        rescue RestClient::Conflict
-          # if we get a 409 back, a previous run likely died mid-task but it
-          # won't hurt this run.
-          Rails.logger.info(_("Group %{id} already created.") % {:id => input[:id]})
-        end
-
-        def group_export_distributor
-          Runcible::Models::GroupExportDistributor.new(false, false)
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository_group/delete.rb

@@ -1,17 +0,0 @@
-module Actions
-  module Pulp
-    module RepositoryGroup
-      class Delete < Pulp::Abstract
-        include Helpers::Presenter
-
-        input_format do
-          param :id
-        end
-
-        def run
-          pulp_resources.repository_group.delete(input[:id])
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository_group/export.rb

@@ -1,51 +0,0 @@
-module Actions
-  module Pulp
-    module RepositoryGroup
-      class Export < Pulp::AbstractAsyncTask
-        include Helpers::Presenter
-
-        input_format do
-          param :id
-          param :export_to_iso
-          param :export_directory # NB: this param is only used when not exporting to ISO
-          param :start_date
-          param :iso_size
-        end
-
-        def invoke_external_task
-          override_config = { :incremental_export_repomd => true }
-
-          if input[:start_date]
-            override_config[:start_date] = input[:start_date]
-          end
-
-          if input[:iso_size]
-            override_config[:iso_size] = input[:iso_size]
-          end
-
-          unless input[:export_to_iso]
-            override_config[:export_dir] = input[:export_directory]
-          end
-
-          optional = {:override_config => override_config}
-
-          pulp_resources.
-            repository_group.publish(input[:id], distributor_id(input[:id]), optional)
-        end
-
-        private
-
-        def distributor_id(pulp_id)
-          distributor = repo_group_distributors(pulp_id).find do |dist|
-            dist["distributor_type_id"] == 'group_export_distributor'
-          end
-          distributor['id']
-        end
-
-        def repo_group_distributors(pulp_id)
-          pulp_resources.repository_group.retrieve_distributors(pulp_id)
-        end
-      end
-    end
-  end
-end

data/app/lib/katello/util/content_overrides_migrator.rb

@@ -1,98 +0,0 @@
-module Katello
-  module Util
-    class ContentOverridesMigrator # used in Actions::Katello::Organization::SimpleContentAccess::PrepareContentOverrides
-      include ActionView::Helpers::TextHelper
-
-      def initialize(organization:)
-        @organization = organization
-      end
-
-      def execute_non_sca_overrides!
-        host_errors = create_disabled_overrides_for_non_sca_org_hosts(organization: @organization)
-        ak_errors = create_disabled_overrides_for_non_sca_org_activation_keys(organization: @organization)
-
-        total_errors = host_errors + ak_errors
-        finish_message = "Finished creating overrides in non-SCA org; #{total_errors == 0 ? "no errors" : "#{pluralize(total_errors, "error")}"}"
-        messages = { result: finish_message, errors: total_errors }
-        messages[:host_errors] = "Hosts - #{pluralize(host_errors, "error")} creating disabled overrides for unsubscribed content; see log messages above" if host_errors > 0
-        messages[:ak_errors] = "Activation keys - #{pluralize(ak_errors, "error")} creating disabled overrides for unsubscribed content; see log messages above" if ak_errors > 0
-        messages[:success_message] = "Organization may now be switched to Simple Content Access mode without any change in access to content." if total_errors == 0
-        Rails.logger.info finish_message
-        Rails.logger.info messages[:host_errors] if messages[:host_errors]
-        Rails.logger.info messages[:ak_errors] if messages[:ak_errors]
-        Rails.logger.info messages[:success_message] if messages[:success_message]
-        messages
-      end
-
-      def create_disabled_overrides_for_non_sca(consumable:)
-        content_finder = ::Katello::ProductContentFinder.new(
-                match_subscription: false,
-                match_environment: false,
-                consumable: consumable
-              )
-        subscribed_content_finder = ::Katello::ProductContentFinder.new(
-          match_subscription: true,
-          match_environment: false,
-          consumable: consumable
-        )
-        candlepin_resource = consumable.is_a?(::Katello::Host::SubscriptionFacet) ? ::Katello::Resources::Candlepin::Consumer : ::Katello::Resources::Candlepin::ActivationKey
-        consumable_id = consumable.is_a?(::Katello::Host::SubscriptionFacet) ? consumable.uuid : consumable.cp_id
-        repos_with_existing_overrides = candlepin_resource.content_overrides(consumable_id).map do |override|
-          override[:contentLabel]
-        end
-        unsubscribed_content = content_finder.custom_content_labels - subscribed_content_finder.custom_content_labels - repos_with_existing_overrides
-        new_overrides = unsubscribed_content.map do |repo_label|
-          ::Katello::ContentOverride.new(
-            repo_label,
-            { name: "enabled", value: "0" } # Override to disabled
-          )
-        end
-        return if new_overrides.blank?
-        if consumable.is_a? ::Katello::Host::SubscriptionFacet
-          ::Katello::Resources::Candlepin::Consumer.update_content_overrides(
-            consumable.uuid,
-            new_overrides.map(&:to_entitlement_hash)
-          )
-        else
-          ::Katello::Resources::Candlepin::ActivationKey.update_content_overrides(
-            consumable.cp_id,
-            new_overrides.map(&:to_entitlement_hash)
-          )
-        end
-      end
-
-      def create_disabled_overrides_for_non_sca_org_hosts(organization:)
-        errors = 0
-        fail _("Organization must be specified") if organization.blank?
-        return 0 if organization.simple_content_access? # subscription attachment is meaningless with SCA
-        Rails.logger.info("Hosts - Creating disabled overrides for unsubscribed content in organization #{organization.name}")
-        # only registered hosts with content!
-        hosts_to_update = organization.hosts.joins(:subscription_facet).where.not("#{Katello::Host::SubscriptionFacet.table_name}.host_id" => nil)
-        hosts_to_update.each do |host|
-          create_disabled_overrides_for_non_sca(consumable: host.subscription_facet)
-        rescue => e
-          errors += 1
-          Rails.logger.error("Failed to update host #{host.name}: #{e.message}")
-          Rails.logger.debug e.backtrace.join("\n")
-        end
-        errors
-      end
-
-      def create_disabled_overrides_for_non_sca_org_activation_keys(organization:)
-        errors = 0
-        fail _("Organization must be specified") if organization.blank?
-        return 0 if organization.simple_content_access? # subscription attachment is meaningless with SCA
-        Rails.logger.info("Activation keys - Creating disabled overrides for unsubscribed content in organization #{organization.name}")
-        aks_to_update = organization.activation_keys
-        aks_to_update.each do |ak|
-          create_disabled_overrides_for_non_sca(consumable: ak)
-        rescue => e
-          errors += 1
-          Rails.logger.error("Failed to update activation key #{ak.name}: #{e.message}")
-          Rails.logger.debug e.backtrace.join("\n")
-        end
-        errors
-      end
-    end
-  end
-end

data/app/lib/katello/util/package_clause_generator.rb

@@ -1,77 +0,0 @@
-module Katello
-  module Util
-    class PackageClauseGenerator
-      include Util::FilterClauseGenerator
-
-      def copy_clause
-        clauses = super
-        {"$and" => [{"is_modular" => false}, clauses]} unless clauses.blank?
-      end
-
-      def remove_clause
-        clauses = super
-        {"$and" => [{"is_modular" => false}, clauses]} unless clauses.blank?
-      end
-
-      protected
-
-      def fetch_filters
-        ContentViewFilter.yum(false)
-      end
-
-      def collect_clauses(repo, filters)
-        [ContentViewErratumFilter, ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
-          content_type_filters = filters.where(:type => filter_class.to_s)
-          make_package_clauses(repo, content_type_filters) unless content_type_filters.empty?
-        end
-      end
-
-      def whitelist_non_matcher_clause
-        {"filename" => {"$not" => {"$exists" => true}}}
-      end
-
-      def whitelist_all_matcher_clause
-        {"filename" => {"$exists" => true}}
-      end
-
-      def make_package_clauses(repo, filters)
-        content_type = filters.first.content_type
-        pulp_content_clauses = filters.collect do |filter|
-          filter.generate_clauses(repo)
-        end
-        pulp_content_clauses.flatten!
-        pulp_content_clauses.compact!
-
-        unless pulp_content_clauses.empty?
-          package_clauses_from_content(content_type, pulp_content_clauses)
-        end
-      end
-
-      def package_clauses_from_content(content_type, pulp_content_clauses)
-        case content_type
-        when ContentViewFilter::ERRATA
-          package_clauses_for_errata(pulp_content_clauses)
-        when ContentViewFilter::PACKAGE_GROUP
-          package_clauses_for_group(pulp_content_clauses)
-        else
-          {"$or" => pulp_content_clauses}
-        end
-      end
-
-      # input ->  [{"type"=>{"$in"=>[:bugfix, :security]}}] <- Errata Pulp Clauses
-      # output -> {"filename" => {"$in" => {"foo.el6.noarch", "..."}}} <- Packages belonging to those errata
-      def package_clauses_for_errata(errata_clauses = [])
-        pkg_filenames = Katello::Erratum.list_filenames_by_clauses(@repo, errata_clauses)
-        {'filename' => {"$in" => pkg_filenames}} unless pkg_filenames.empty?
-      end
-
-      # input ->  [{"name"=>{"$in"=>["foo", "bar"]}}] <- Package group pulp clauses
-      # output -> {"names" => {"$in" => {"foo", "..."}}}  <- packages belonging to those packages
-      def package_clauses_for_group(group_clauses = [])
-        group_clauses = {"$or" => group_clauses}
-        pkg_names = Katello::PackageGroup.list_by_filter_clauses(group_clauses)
-        {'name' => {"$in" => pkg_names}} unless pkg_names.empty?
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Katello
-  module Glue
-    module Pulp
-      module PulpErrors
-        class ServiceUnavailable < HttpErrors::ServiceUnavailable; end
-      end
-    end
-  end
-end