katello 4.7.4 → 4.8.0.rc1

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/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