katello 4.13.1 → 4.14.0.rc1.1

data/app/services/katello/pulp3/content_view_version/import_validator.rb.bak

@@ -1,166 +0,0 @@
-module Katello
-  module Pulp3
-    module ContentViewVersion
-      class ImportValidator
-        def initialize(import:)
-          @content_view = import.content_view
-          @path = import.path
-          @smart_proxy = import.smart_proxy
-          @organization = import.organization
-          @metadata_map = import.metadata_map
-          @interested_repos = import.intersecting_repos_library_and_metadata
-          @redhat_library_products = redhat_library_products
-        end
-
-        def check!
-          if @metadata_map.content_view.blank? && !metadata_map.syncable_format?
-            fail _("Content view not provided in the metadata")
-          end
-
-          ensure_non_syncable_path_valid! unless @metadata_map.syncable_format?
-          ensure_pulp_importable!
-          if @content_view && !@content_view.default?
-            ensure_non_composite!
-            ensure_importing_cvv_does_not_exist!
-            ensure_from_cvv_exists!
-          end
-          ensure_manifest_imported!
-          ensure_metadata_matches_repos_in_library!
-          ensure_redhat_products_metadata_are_in_the_library!
-        end
-
-        def ensure_non_syncable_path_valid!
-          uri = URI(@path)
-          unless uri.scheme.blank? || uri.scheme == "file"
-            fail _("Invalid path provided. Content can be only imported from file system. ")
-          end
-        end
-
-        def ensure_non_composite!
-          return if @content_view.blank?
-          fail _("Content cannot be imported into a Composite Content View. ") if @content_view.composite?
-        end
-
-        def ensure_pulp_importable!
-          return if @metadata_map.syncable_format?
-          api = ::Katello::Pulp3::Api::Core.new(@smart_proxy).importer_check_api
-          response = api.pulp_import_check_post(toc: "#{@path}/#{@metadata_map.toc}")
-          unless response.toc.is_valid
-            fail response.toc.messages.join("\n")
-          end
-        end
-
-        def ensure_importing_cvv_does_not_exist!
-          major = @metadata_map.content_view_version.major
-          minor = @metadata_map.content_view_version.minor
-
-          if ::Katello::ContentViewVersion.where(major: major, minor: minor, content_view: @content_view).exists?
-            fail _("Content View Version specified in the metadata - '%{name}' already exists. "\
-                    "If you wish to replace the existing version, delete %{name} and try again. " % { name: "#{@content_view.name} #{major}.#{minor}" })
-          end
-        end
-
-        def ensure_from_cvv_exists!
-          major = @metadata_map.content_view_version.major
-          minor = @metadata_map.content_view_version.minor
-
-          if @metadata_map.from_content_view_version
-            from_major = @metadata_map.from_content_view_version.major
-            from_minor = @metadata_map.from_content_view_version.minor
-
-            unless ::Katello::ContentViewVersion.where(major: from_major, minor: from_minor, content_view: @content_view).exists?
-              fail _("Prior Content View Version specified in the metadata - '%{name}' does not exist. "\
-                      "Please import the metadata for '%{name}' before importing '%{current}' " % { name: "#{@content_view.name} #{from_major}.#{from_minor}",
-                                                                                                    current: "#{@content_view.name} #{major}.#{minor}"})
-            end
-          end
-        end
-
-        def ensure_manifest_imported!
-          any_rh_repos = @metadata_map.repositories.any?(&:redhat)
-          if any_rh_repos && !@organization.manifest_imported?
-            fail _("No manifest found. Import a manifest with the appropriate subscriptions "\
-                   "before importing content.")
-          end
-        end
-
-        def ensure_metadata_matches_repos_in_library!
-          bad_repos = @interested_repos.select do |katello_repo|
-            metadata_repo = metadata_repo_for_katello_repo(katello_repo)
-
-            next unless metadata_repo
-
-            !(katello_repo.content_type == metadata_repo.content_type &&
-              katello_repo.redhat? == metadata_repo.redhat)
-          end
-
-          if bad_repos.any?
-            fail _("The following repositories provided in the import metadata have an incorrect content type or provider type. "\
-                    "Make sure the export and import repositories are of the same type before importing\n "\
-                    "%{repos}" % { repos: generate_product_repo_i18n_string(bad_repos).join("")}
-                  )
-          end
-        end
-
-        def ensure_redhat_products_metadata_are_in_the_library!
-          missing = @metadata_map.repositories.select do |repo|
-            repo.redhat && katello_product_for_metadata_repo(repo).nil?
-          end
-
-          if missing.any?
-            repos_in_import = generate_product_repo_i18n_string(missing)
-            fail _("The organization's manifest does not contain the subscriptions required to enable the following repositories.\n "\
-                    "%{repos}" % { repos: repos_in_import.join("")}
-                  )
-          end
-        end
-
-        def ensure_no_missing_rh_repos!
-          rh_repos = @metadata_map.repositories.select { |r| r.redhat }
-          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
-            organization: @organization,
-            metadata_repositories: rh_repos,
-            syncable_format: @metadata_map.syncable_format?,
-            path: path
-          )
-          helper.generate!
-          rh_repos = rh_repos.select do |repo|
-          end
-        end
-
-
-        private
-
-        def katello_product_for_metadata_repo(metadata_repo)
-          @redhat_library_products.find do |product|
-            if metadata_repo.redhat && metadata_repo.product.cp_id
-              product.cp_id == metadata_repo.product.cp_id
-            else
-              product.label == metadata_repo.product.label
-            end
-          end
-        end
-
-        def metadata_repo_for_katello_repo(repo)
-          @metadata_map.repositories.find do |metadata_repo|
-            if repo.redhat? && metadata_repo.product.cp_id
-              repo.label == metadata_repo.label && repo.product.cp_id == metadata_repo.product.cp_id
-            else
-              repo.label == metadata_repo.label && repo.product.label == metadata_repo.product.label
-            end
-          end
-        end
-
-        def redhat_library_products
-          ::Katello::Product.in_org(@organization).redhat
-        end
-
-        def generate_product_repo_i18n_string(metadata_repos)
-          metadata_repos.map do |repo|
-            _("\n* Product = '%{product}', Repository = '%{repository}'" % { product: repo.product.name, repository: repo.name })
-          end
-        end
-      end
-    end
-  end
-end

data/app/services/katello/pulp3/content_view_version/importable_repositories.rb.bak

@@ -1,164 +0,0 @@
-module Katello
-  module Pulp3
-    module ContentViewVersion
-      class ImportableRepositories
-        attr_reader :creatable, :updatable
-
-        def initialize(organization:,
-                       metadata_repositories:,
-                       syncable_format: false,
-                       path: nil)
-          @organization = organization
-          @metadata_repositories = metadata_repositories
-          @creatable = []
-          @updatable = []
-          @syncable_format = syncable_format
-          @path = path
-        end
-
-        def find_root_repo(metadata_repo:, product:)
-          product.root_repositories.find do |r|
-            if metadata_repo.content&.id && metadata_repo.redhat
-              next if (r.content.cp_content_id != metadata_repo.content.id)
-              next if metadata_repo.arch_substituted? && r.arch != metadata_repo.arch
-              next if metadata_repo.release_version_substituted? && (r.major != metadata_repo.major ||
-                r.minor != metadata_repo.minor)
-              true
-            else
-              r.label == metadata_repo.label
-            end
-          end
-        end
-
-        def generate!
-          # For Red Hat repositories or Custom Repositories in the metadata exclusively
-          # Set up a 2 different list of importable root repositories
-          # creatable: repos that are part of the metadata but not in the library.
-          #         They are ready to be created
-          # updatable: repo that are both in the metadata and library.
-          #         These may contain updates to the repo and hence ready to be updated.
-          @metadata_repositories.each do |repo|
-            product = product_for_metadata_repo(repo)
-            fail _("Unable to find product '%s' in organization '%s'" % [repo.product.label, @organization.name]) if product.blank?
-
-            root = find_root_repo(product: product, metadata_repo: repo)
-            if root
-              updatable << { repository: root, options: update_repo_params(repo) }
-            elsif repo.redhat
-              product_content = fetch_product_content(repo.content, product)
-              substitutions = {}
-              substitutions[:basearch] = repo.arch if repo.content.arch_substituted?
-              substitutions[:releasever] = repo.minor if repo.content.release_version_substituted?
-              create_options = {
-                product: product,
-                content: product_content,
-                substitutions: substitutions,
-                override_url: fetch_feed_url(repo)
-              }
-              create_options[:override_arch] = repo.arch
-              creatable << create_options
-            else
-              creatable << { repository: product.add_repo(create_repo_params(repo, product)) }
-            end
-          end
-        end
-
-        private
-
-        def find_unique_name(metadata_repo, product)
-          name = metadata_repo.name
-          i = 1
-          while product.root_repositories.where(name: name).exists?
-            name = "#{metadata_repo.name} #{i}"
-            i += 1
-          end
-          name
-        end
-
-        def product_for_metadata_repo(repo)
-          if repo.redhat && repo.product.cp_id
-            @organization.products.includes(:root_repositories).find_by(cp_id: repo.product.cp_id)
-          else
-            @organization.products.includes(:root_repositories).find_by(label: repo.product.label)
-          end
-        end
-
-        def fetch_product_content(content_metadata, product)
-          query = ::Katello::Content.joins(:product_contents).where("#{Katello::ProductContent.table_name}.product_id": product.id)
-          table_name = Katello::Content.table_name
-          if content_metadata&.id
-            query.find_by("#{table_name}.cp_content_id": content_metadata.id)
-          else
-            query.find_by("#{table_name}.label": content_metadata.label)
-          end
-        end
-
-        def gpg_key_id(metadata_repo)
-          if metadata_repo.gpg_key
-            @organization.gpg_keys.find_by(name: metadata_repo.gpg_key.name).id
-          end
-        end
-
-        def create_repo_params(metadata_repo, product)
-          keys = [
-            :label,
-            :description,
-            :arch,
-            :unprotected,
-            :content_type,
-            :checksum_type,
-            :os_versions,
-            :major,
-            :minor,
-            :download_policy,
-            :mirroring_policy
-          ]
-
-          params = { name: find_unique_name(metadata_repo, product) }
-          params[:gpg_key_id] = gpg_key_id(metadata_repo)
-          keys.each do |key|
-            params[key] = metadata_repo.send(key)
-          end
-          url = fetch_feed_url(metadata_repo)
-          params[:url] = url if url
-          params
-        end
-
-        def fetch_feed_url(metadata_repo)
-          return unless @syncable_format
-          uri = URI(@path)
-          if uri.scheme.blank? || uri.scheme == "file"
-            "file://#{uri.path.chomp('/')}#{metadata_repo.content.url}"
-          else
-            "#{@path.chomp('/')}#{metadata_repo.content.url}"
-          end
-        end
-
-        def update_repo_params(metadata_repo)
-          keys = [
-            :description,
-            :arch,
-            :unprotected,
-            :checksum_type,
-            :os_versions,
-            :major,
-            :minor,
-            :download_policy,
-            :mirroring_policy
-          ]
-          params = {}
-          url = fetch_feed_url(metadata_repo)
-          params[:url] = url if url
-          params[:gpg_key_id] = gpg_key_id(metadata_repo)
-
-          keys.each do |key|
-            value = metadata_repo.send(key)
-            params[key] = value if value
-          end
-
-          params
-        end
-      end
-    end
-  end
-end

data/lib/katello/tasks/update_repository_expiry.rake

@@ -1,114 +0,0 @@
-namespace :katello do
-  def commit?
-    ENV['COMMIT'] == 'true' || ENV['FOREMAN_UPGRADE'] == '1'
-  end
-
-  desc "Regnerate metadata for all repositories. Specify CONTENT_VIEW=name and LIFECYCLE_ENVIRONMENT=name to narrow repositories."
-  task :regenerate_repo_metadata => ["dynflow:client", "check_ping"] do
-    User.current = User.anonymous_api_admin
-    repos = lookup_repositories
-
-    if repos.any?
-      task = ForemanTasks.async_task(Actions::Katello::Repository::BulkMetadataGenerate, repos.all.order_by_root(:name))
-      puts "Regenerating #{repos.count} repositories.  You can monitor these on task id #{task.id}\n"
-    else
-      puts "No repositories found for regeneration."
-    end
-  end
-
-  desc "Refresh repository metadata for all repositories. Specify CONTENT_VIEW=name and LIFECYCLE_ENVIRONMENT=name to narrow repositories."
-  task :refresh_pulp_repo_details => ["dynflow:client", "check_ping"] do
-    User.current = User.anonymous_api_admin
-    repos = lookup_repositories
-
-    if repos.any?
-      task = ForemanTasks.async_task(::Actions::BulkAction, Actions::Katello::Repository::RefreshRepository, repos.all.order_by_root(:name))
-      puts "Refreshing #{repos.count} repositories.  You can monitor these on task id #{task.id}\n"
-    else
-      puts "No repositories found for regeneration."
-    end
-  end
-
-  desc "Correct missing pulp repositories. Specify CONTENT_VIEW=name and LIFECYCLE_ENVIRONMENT=name to narrow repositories.  COMMIT=true to perform operation."
-  task :correct_repositories => ["environment", "check_ping"] do
-    puts "All operations will be skipped.  Re-run with COMMIT=true to perform corrections." unless commit?
-
-    User.current = User.anonymous_api_admin
-    repos = lookup_repositories
-
-    repos.find_each.with_index do |repo, index|
-      puts "Processing Repository #{index + 1}/#{repos.count}: #{repo.name} (#{repo.id})"
-      unless repo_exists?(repo)
-        handle_missing_repo(repo)
-      end
-    end
-
-    ::Katello::RootRepository.orphaned.each do |root_repo|
-      handle_missing_root_repo(root_repo)
-    end
-  end
-
-  desc "Change the download policy of all repos. Specify DOWNLOAD_POLICY=policy. Options are immediate or on_demand."
-  task :change_download_policy => ["environment", "check_ping"] do
-    policy = ENV['DOWNLOAD_POLICY']
-    unless ::Katello::RootRepository::DOWNLOAD_POLICIES.include?(policy)
-      puts "Invalid download policy specified: '#{policy}'. "
-      puts "Options are immediate or on_demand."
-      next
-    end
-
-    User.current = User.anonymous_api_admin
-    repos = Katello::Repository.yum_type.where(library_instance_id: nil)
-
-    repos.find_each.with_index do |repo, index|
-      puts "Processing Repository #{index + 1}/#{repos.count}: #{repo.name} (#{repo.id})"
-      begin
-        ForemanTasks.sync_task(::Actions::Katello::Repository::Update, repo.root,
-                               download_policy: policy)
-      rescue => e
-        puts "Failed to update repository #{repo.name} (#{repo.id}): #{e.message}"
-      end
-    end
-  end
-
-  def lookup_repositories
-    lifecycle_envs = Katello::KTEnvironment.where(:name => ENV['LIFECYCLE_ENVIRONMENT']) if ENV['LIFECYCLE_ENVIRONMENT']
-    content_views = Katello::ContentView.where(:name => ENV['CONTENT_VIEW']) if ENV['CONTENT_VIEW']
-
-    repos = ::Katello::Repository
-    repos = repos.in_environment(lifecycle_envs) if lifecycle_envs
-    repos = repos.in_content_views(content_views) if content_views
-    repos
-  end
-
-  def repo_exists?(repo)
-    if SmartProxy.pulp_primary!.pulp3_support?(repo)
-      backend_service = repo.backend_service(SmartProxy.pulp_primary!)
-      return false unless backend_service&.repository_reference&.repository_href
-      backend_service.api.repositories_api.read(backend_service.repository_reference.repository_href)
-    else
-      false
-    end
-    true
-  rescue StandardError => e
-    return false if e.code == 404
-  end
-
-  def handle_missing_repo(repo)
-    puts "Repository #{repo.id} Missing"
-    if repo.content_view.default?
-      puts "Recreating #{repo.id}"
-      if commit?
-        ForemanTasks.sync_task(::Actions::Katello::Repository::Create, repo, force_repo_create: true)
-        repo.reload.index_content
-      end
-    else
-      puts "Deleting #{repo.id}"
-      ForemanTasks.sync_task(::Actions::Katello::Repository::Destroy, repo) if commit?
-    end
-  end
-
-  def handle_missing_root_repo(root_repo)
-    root_repo.destroy! if commit?
-  end
-end