katello 4.13.0 → 4.14.0.rc1

data/app/lib/actions/katello/repository/import_upload.rb

@@ -58,8 +58,8 @@ module Actions
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
-          if input[:sync_capsule]
-            ForemanTasks.async_task(Katello::Repository::CapsuleSync, repository) if Setting[:foreman_proxy_content_auto_sync]
+          if input[:sync_capsule] && (Setting[:foreman_proxy_content_auto_sync])
+            ForemanTasks.async_task(Katello::Repository::CapsuleSync, repository)
           end
           output[:upload_results] = results_to_json(input[:upload_results])
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
@@ -92,10 +92,8 @@ module Actions
                 json_results << {:type => 'file'}
               end
             end
-            unless json_results.size
-              if result[:content_unit_href]
-                json_results << {:type => 'file'}
-              end
+            if !json_results.size && (result[:content_unit_href])
+              json_results << {:type => 'file'}
             end
           end
           json_results

data/app/lib/actions/katello/repository/metadata_generate.rb

@@ -3,6 +3,7 @@ module Actions
     module Repository
       class MetadataGenerate < Actions::EntryAction
         def plan(repository, options = {})
+          return if repository.root.is_container_push && repository.library_instance?
           action_subject(repository)
           repository.check_ready_to_act!
           source_repository = options.fetch(:source_repository, nil)

data/app/lib/actions/katello/repository/update.rb

@@ -92,7 +92,7 @@ module Actions
           # match the ACS content type and have a non-nil URL
           product = repository.product
           repo_content_types = Set.new
-          product.repositories.each do |test_repo|
+          product.acs_compatible_repositories.each do |test_repo|
             # we need to check id because test_repo will still contain the old, non-nil url
             repo_content_types.add(test_repo.content_type) if (repository.id != test_repo.id) && test_repo.url.present?
           end
@@ -110,11 +110,11 @@ module Actions
         end
 
         def create_acs?(old_url, new_url)
-          old_url.nil? && new_url.present?
+          (old_url.nil? || old_url.start_with?('uln')) && new_url.present? && !new_url.start_with?('uln')
         end
 
         def delete_acs?(old_url, new_url)
-          old_url.present? && new_url.nil?
+          old_url.present? && (new_url.nil? || new_url.start_with?('uln'))
         end
       end
     end

data/app/lib/actions/katello/repository_set/enable_repository.rb

@@ -6,8 +6,7 @@ module Actions
           _("Enable")
         end
 
-        def plan(product, content, substitutions, override_url: nil,
-                 override_arch: nil)
+        def plan(product, content, substitutions, opts = {})
           mapper = ::Katello::Candlepin::RepositoryMapper.new(product,
                                                                content,
                                                                substitutions)
@@ -16,10 +15,10 @@ module Actions
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
           end
           repository = mapper.build_repository
-          repository.root.arch = override_arch if override_arch.present?
-          if override_url
-            repository.root.url = override_url
-            repository.root.download_policy = ::Katello::RootRepository::DOWNLOAD_IMMEDIATE if URI(override_url).scheme == 'file'
+          repository.root.arch = opts[:override_arch] if opts[:override_arch].present?
+          if opts[:override_url]
+            repository.root.url = opts[:override_url]
+            repository.root.download_policy = ::Katello::RootRepository::DOWNLOAD_IMMEDIATE if URI(opts[:override_url]).scheme == 'file'
           end
           plan_action(Repository::Create, repository, clone: false)
           action_subject(repository)

data/app/lib/actions/middleware/backend_services_check.rb

@@ -28,9 +28,10 @@ module Actions
       def capsule_id(args)
         capsule_id = nil
         args.each do |arg|
-          if arg.is_a? SmartProxy
+          case arg
+          when SmartProxy
             capsule_id = arg.id
-          elsif arg.is_a? Hash
+          when Hash
             capsule_id = arg[:capsule_id] || arg[:smart_proxy_id]
           end
           break if capsule_id

data/app/lib/actions/pulp3/abstract_async_task.rb

@@ -96,10 +96,9 @@ module Actions
       def transform_task_response(response)
         response = [] if response.nil?
         response = [response] unless response.is_a?(Array)
-        response = response.map do |task|
+        response.map do |task|
           task.as_json
         end
-        response
       end
 
       def check_for_errors
@@ -166,8 +165,7 @@ module Actions
       def get_task_label(name, href)
         name = name.split('.').last if name
         href = href.split('-').last[0...-1] if href
-        label = "%s (ID: %s)" % [name, href]
-        label
+        "%s (ID: %s)" % [name, href]
       end
     end
   end

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

@@ -17,8 +17,7 @@ module Actions
           if repository
             [repository]
           else
-            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
-            repositories
+            smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
           end
         end
       end

data/app/lib/actions/pulp3/orchestration/repository/copy_all_units.rb

@@ -23,7 +23,7 @@ module Actions
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: action.output[:pulp_tasks])
                   copy_actions = []
                   #since we're creating a new version from the first repo, start copying at the 2nd
-                  source_repositories[1..-1].each do |source_repo|
+                  source_repositories[1..].each do |source_repo|
                     # TODO: In a future refactor, can :copy_all be utilized?  Filters should not be needed in this code segment.
                     copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent, source_repo, smart_proxy, target_repo,
                                                 filter_ids: filter_ids, solve_dependencies: solve_dependencies,
@@ -32,6 +32,10 @@ module Actions
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_actions.last.output[:pulp_tasks])
                 end
               end
+            elsif source_repositories.first.root.is_container_push
+              copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
+                                        copy_all: true)
+              plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
             else
               plan_self(source_version_repo_id: source_repositories.first.id,
                         target_repo_id: target_repo.id)

data/app/lib/actions/pulp3/orchestration/repository/delete.rb

@@ -9,10 +9,13 @@ module Actions
               plan_action(Actions::Pulp3::Repository::DeleteDistributions, repository.id, smart_proxy)
 
               if repository.content_view.default?
-                #we're deleting the library instance, so just delete the whole pulp3 repo
+                # Container push repositories must be deleted through the distribution
+                return if repository.root.is_container_push
+
+                # We're deleting the library instance, so just delete the whole pulp3 repo
                 plan_action(Actions::Pulp3::Repository::Delete, repository.id, smart_proxy)
               elsif repository.environment.nil?
-                #we're deleting the archived instance, so delete the version
+                # We're deleting the archived instance, so delete the version
                 plan_action(Actions::Pulp3::Repository::DeleteVersion, repository, smart_proxy)
               end
             end

data/app/lib/actions/pulp3/repository/create_publication.rb

@@ -14,6 +14,10 @@ module Actions
         def invoke_external_task
           unless input[:skip_publication_creation]
             repository = ::Katello::Repository.find(input[:repository_id])
+            if repository.root.sha1_checksum?
+              repository.root.remove_sha1_checksum_type
+              repository.root.save!
+            end
             output[:response] = repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
           end
         end

data/app/lib/actions/pulp3/repository/save_version.rb

@@ -20,11 +20,9 @@ module Actions
           end
 
           output[:publication_provided] = false
-          if input[:tasks].present?
-            if (publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks]))
-              repo.update(:publication_href => publication_href)
-              output[:publication_provided] = true
-            end
+          if input[:tasks].present? && (publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks]))
+            repo.update(:publication_href => publication_href)
+            output[:publication_provided] = true
           end
 
           if version_href

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -259,13 +259,9 @@ module Katello
         labels = 'label ^ (Actions::Katello::Host::Erratum::Install, Actions::Katello::Host::Erratum::ApplicableErrataInstall)'
         select = 'foreman_tasks_tasks.*'
 
-        if Katello.with_remote_execution?
-          new_labels = 'label = Actions::RemoteExecution::RunHostJob AND remote_execution_feature.label ^ (katello_errata_install, katello_errata_install_by_search)'
-          labels = [labels, new_labels].map { |label| "(#{label})" }.join(' OR ')
-          select += ',template_invocations.id AS template_invocation_id'
-        else
-          select += ',NULL AS template_invocation_id'
-        end
+        new_labels = 'label = Actions::RemoteExecution::RunHostJob AND remote_execution_feature.label ^ (katello_errata_install, katello_errata_install_by_search)'
+        labels = [labels, new_labels].map { |label| "(#{label})" }.join(' OR ')
+        select += ',template_invocations.id AS template_invocation_id'
 
         search = [search_up_to, search_since, search_result, "state = stopped", labels].compact.join(' and ')
 
@@ -302,8 +298,8 @@ module Katello
               current_erratum_errata_type = current_erratum[1]
               current_erratum_issued = current_erratum.last
 
-              if filter_errata_type != 'all'
-                next unless filter_errata_type == current_erratum_errata_type
+              if filter_errata_type != 'all' && !(filter_errata_type == current_erratum_errata_type)
+                next
               end
 
               hash = {

data/app/lib/katello/errors.rb

@@ -134,6 +134,7 @@ module Katello
     end
 
     class UpstreamCandlepinError < CandlepinError; end
+
     class UpstreamConsumerGone < StandardError
       def message
         _("The manifest doesn't exist on console.redhat.com. " \

data/app/lib/katello/http_resource.rb

@@ -8,6 +8,7 @@ module Katello
 
     class RestClientException < StandardError
       attr_reader :service_code, :code
+
       def initialize(params)
         super params[:message]
         @service_code = params[:service_code]

data/app/lib/katello/lazy_accessor.rb

@@ -24,7 +24,7 @@ module Katello
       def lazy_accessor(*args)
         options = args.extract_options!
         @lazy_attributes = [] if @lazy_attributes.nil?
-        @lazy_attributes = @lazy_attributes.concat args
+        @lazy_attributes.concat args
         @lazy_attributes_options ||= {}
         fail ArgumentError, "Attribute names must be symbols" if args.any? { |attribute| !attribute.is_a?(Symbol) }
         redefined_attr = args.find { |attribute| instance_methods.include?(attribute.to_s) }

data/app/lib/katello/repo_discovery.rb

@@ -4,22 +4,11 @@ module Katello
   class RepoDiscovery
     include Katello::Util::HttpProxy
 
-    attr_reader :found, :crawled, :to_follow
-
-    # rubocop:disable Metrics/ParameterLists
-    def initialize(url, content_type = 'yum', upstream_username = nil,
-      upstream_password = nil, search = '*', crawled = [],
-      found = [], to_follow = [])
-      @uri = uri(url)
-      @content_type = content_type
-      @upstream_username = upstream_username.empty? ? nil : upstream_username
-      @upstream_password = upstream_password.empty? ? nil : upstream_password
-      @search = search
-      @found = found
-      @crawled = crawled
-      @to_follow = to_follow
+    def self.class_for(content_type)
+      repo_discovery_class = RepositoryTypeManager.find_repository_type(content_type)&.repo_discovery_class
+      fail _("Content type does not support repo discovery") unless repo_discovery_class
+      repo_discovery_class
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def uri(url)
       #add a / on the end, as directories require it or else
@@ -27,180 +16,5 @@ module Katello
       url += '/' unless url.ends_with?('/')
       URI(url)
     end
-
-    def run(resume_point)
-      if @content_type == 'docker'
-        docker_search
-      else
-        if @uri.scheme == 'file'
-          file_crawl(uri(resume_point))
-        elsif %w(http https).include?(@uri.scheme)
-          http_crawl(uri(resume_point))
-        else
-          fail _("Unsupported URL protocol %s.") % @uri.scheme
-        end
-      end
-    end
-
-    private
-
-    def parse_parameter(field_value)
-      field_value.lstrip!
-      i = field_value.index(/[ \t=;,]/) || field_value.length
-      name = field_value.slice!(0, i).downcase(:ascii)
-      field_value.lstrip!
-      if field_value.delete_prefix!('=')
-        field_value.lstrip!
-        if field_value.delete_prefix!('"')
-          value = ''
-          until field_value.empty?
-            break if field_value.delete_prefix!('"')
-            field_value.delete_prefix!("\\")
-            value += field_value.slice!(0, 1) || ''
-          end
-        else
-          i = field_value.index(/[;,]/) || field_value.length
-          value = field_value.slice!(0, i)
-        end
-      end
-      {name: name, value: value || ''}
-    end
-
-    def parse_parameters(field_value)
-      seen_rel = false
-      has_next_rel = false
-      has_anchor = false
-      until field_value.empty?
-        field_value.lstrip!
-        break if field_value.delete_prefix!(';').nil?
-        param = parse_parameter(field_value)
-        case
-        when param[:name] == 'rel' && !seen_rel
-          seen_rel = true
-          has_next_rel = param[:value].downcase(:ascii).split(/[ \t]/).include?('next')
-        when param[:name] == 'anchor'
-          has_anchor = true
-        end
-      end
-      {has_next_rel: has_next_rel, has_anchor: has_anchor}
-    end
-
-    def get_next_link(link_header)
-      # This code mostly follows Appendix B "Algorithms of Parsing Link Header Fields" of RFC 8288
-      # "Web Linking", <https://www.rfc-editor.org/rfc/rfc8288#appendix-B> (that RFC appears to be
-      # silent about multiple "next" links, so just use the first one and ignore any additional
-      # ones, in the general spirit of being lenient):
-      return nil if link_header.nil?
-      field_value = link_header.clone
-      until field_value.empty?
-        # The following ignores any junk preceding the next <...> link URL:
-        m = field_value.match(/<(.*)>/)
-        break unless m
-        target_string = m[1]
-        field_value = m.post_match
-        params = parse_parameters(field_value)
-        if params[:has_next_rel]
-          # To keep it simple, ignore a link with an (unlikely) anchor parameter; but the RFC
-          # mandates that we "MUST NOT process the link without applying the anchor", so just raise
-          # an exception in that (unlikely) case:
-          fail "anchor not supported" if params[:has_anchor]
-          return target_string
-        end
-      end
-      nil
-    end
-
-    def docker_search
-      request_params = {
-        method: :get,
-        headers: { accept: :json },
-        url: "#{@uri}v1/search?q=#{@search}"
-      }
-
-      request_params[:user] = @upstream_username unless @upstream_username.empty?
-      request_params[:password] = @upstream_password unless @upstream_password.empty?
-      request_params[:proxy] = proxy_uri if proxy
-
-      begin
-        results = RestClient::Request.execute(request_params)
-        JSON.parse(results)['results'].each do |result|
-          @found << result['name']
-        end
-      rescue
-        # Note: v2 endpoint does not support search
-        request_params[:url] = "#{@uri}v2/_catalog"
-        loop do
-          results = RestClient::Request.execute(request_params)
-          JSON.parse(results)['repositories'].each do |result|
-            @found << result
-          end
-          next_uri = get_next_link(results.headers[:link])
-          break if next_uri.nil?
-          request_params[:url] = URI(request_params[:url]).merge(next_uri).to_s
-        end
-      end
-      @found.sort!
-    end
-
-    def anemone_proxy_details
-      details = {}
-
-      if proxy
-        details[:proxy_host] = proxy_host
-        details[:proxy_port] = proxy_port
-        details[:proxy_user] = proxy.username
-        details[:proxy_password] = proxy.password
-      end
-
-      details
-    end
-
-    def http_crawl(resume_point)
-      resume_point_uri = URI(resume_point)
-      resume_point_uri.user = @upstream_username if @upstream_username
-      resume_point_uri.password = @upstream_password if @upstream_password
-
-      Anemone.crawl(resume_point_uri, anemone_proxy_details) do |anemone|
-        anemone.focus_crawl do |page|
-          @crawled << page.url.path
-
-          page.links.each do |link|
-            if link.path.ends_with?('/repodata/')
-              page_url = page.url.clone
-              page_url.user = nil
-              page_url.password = nil
-              @found << page_url.to_s
-            else
-              @to_follow << link.to_s if should_follow?(link.path)
-            end
-          end
-          page.discard_doc! #saves memory, doc not needed
-          []
-        end
-      end
-    end
-
-    def file_crawl(resume_point)
-      if resume_point.path.ends_with?('/repodata/')
-        found_path = Pathname(resume_point.path).parent.to_s
-        @found << "file://#{found_path}"
-      end
-      if resume_point.path == @uri.path
-        Dir.glob("#{@uri.path}**/").each { |path| @to_follow << path }
-        @to_follow.shift
-      end
-      @crawled << resume_point.path
-    end
-
-    def should_follow?(path)
-      #Verify:
-      # * link's path starts with the base url
-      # * link hasn't already been crawled
-      # * link ends with '/' so it should be a directory
-      # * link doesn't end with '/Packages/', as this increases
-      #       processing time and memory usage considerably
-      return path.starts_with?(@uri.path) && !@crawled.include?(path) &&
-           path.ends_with?('/') && !path.ends_with?('/Packages/')
-    end
   end
 end

data/app/lib/katello/resources/candlepin/candlepin_ping.rb

@@ -7,11 +7,6 @@ module Katello
             response = get('/candlepin/status').body
             JSON.parse(response).with_indifferent_access
           end
-
-          def distributor_versions
-            response = get("/candlepin/distributor_versions").body
-            JSON.parse(response)
-          end
         end
       end
     end

data/app/lib/katello/resources/candlepin/owner.rb

@@ -65,7 +65,7 @@ module Katello
             response = JSON.parse(response_json).with_indifferent_access
             if wait_until_complete && response['state'] == 'CREATED'
               while !response['state'].nil? && response['state'] != 'FINISHED' && response['state'] != 'ERROR'
-                path = join_path('candlepin', response['statusPath'][1..-1])
+                path = join_path('candlepin', response['statusPath'][1..])
                 response_json = self.get(path, self.default_headers)
                 response = JSON.parse(response_json).with_indifferent_access
               end

data/app/lib/katello/resources/candlepin/pool.rb

@@ -13,8 +13,7 @@ module Katello
           end
 
           def create(owner_key, attrs)
-            pool = self.post("/candlepin/owners/#{owner_key}/pools", attrs.to_json, self.default_headers).body
-            pool
+            self.post("/candlepin/owners/#{owner_key}/pools", attrs.to_json, self.default_headers).body
           end
 
           def find(pool_id)

data/app/lib/katello/resources/candlepin/upstream_job.rb

@@ -11,7 +11,7 @@ module Katello
           end
 
           def get(id, upstream)
-            url = API_URL
+            url = ENV['REDHAT_RHSM_API_URL'] || API_URL
             response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{url}#{path(id)}", upstream['idCert']['cert'],
               upstream['idCert']['key'], nil)
             job = JSON.parse(response)

data/app/lib/katello/resources/cdn.rb

@@ -104,9 +104,10 @@ module Katello
           # very old infrastructure for now, but that was considered better than having an insecure default.
           net.min_version = OpenSSL::SSL::TLS1_2_VERSION
 
-          if (@options[:verify_ssl] == false) || (@options[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE)
+          case @options[:verify_ssl]
+          when false, OpenSSL::SSL::VERIFY_NONE
             net.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          elsif @options[:verify_ssl].is_a? Integer
+          when Integer
             net.verify_mode = @options[:verify_ssl]
             net.verify_callback = lambda do |preverify_ok, ssl_context|
               if !preverify_ok || ssl_context.error != 0

data/app/lib/katello/resources/discovery/container.rb

@@ -0,0 +1,127 @@
+module Katello
+  module Resources
+    module Discovery
+      class Container < RepoDiscovery
+        attr_reader :found, :crawled, :to_follow
+        def initialize(url, crawled = [], found = [], to_follow = [],
+                       upstream_credentials_and_search = {
+                         upstream_username: nil,
+                         upstream_password: nil,
+                         search: '*'
+                       })
+          @uri = uri(url)
+          @upstream_username = upstream_credentials_and_search[:upstream_username].presence
+          @upstream_password = upstream_credentials_and_search[:upstream_password].presence
+          @search = upstream_credentials_and_search.fetch(:search, '*')
+          @found = found
+          @crawled = crawled
+          @to_follow = to_follow
+        end
+
+        def run(_resume_point)
+          docker_search
+        end
+
+        private
+
+        def parse_parameter(field_value)
+          field_value.lstrip!
+          i = field_value.index(/[ \t=;,]/) || field_value.length
+          name = field_value.slice!(0, i).downcase(:ascii)
+          field_value.lstrip!
+          if field_value.delete_prefix!('=')
+            field_value.lstrip!
+            if field_value.delete_prefix!('"')
+              value = ''
+              until field_value.empty?
+                break if field_value.delete_prefix!('"')
+                field_value.delete_prefix!("\\")
+                value += field_value.slice!(0, 1) || ''
+              end
+            else
+              i = field_value.index(/[;,]/) || field_value.length
+              value = field_value.slice!(0, i)
+            end
+          end
+          {name: name, value: value || ''}
+        end
+
+        def parse_parameters(field_value)
+          seen_rel = false
+          has_next_rel = false
+          has_anchor = false
+          until field_value.empty?
+            field_value.lstrip!
+            break if field_value.delete_prefix!(';').nil?
+            param = parse_parameter(field_value)
+            case
+            when param[:name] == 'rel' && !seen_rel
+              seen_rel = true
+              has_next_rel = param[:value].downcase(:ascii).split(/[ \t]/).include?('next')
+            when param[:name] == 'anchor'
+              has_anchor = true
+            end
+          end
+          {has_next_rel: has_next_rel, has_anchor: has_anchor}
+        end
+
+        def get_next_link(link_header)
+          # This code mostly follows Appendix B "Algorithms of Parsing Link Header Fields" of RFC 8288
+          # "Web Linking", <https://www.rfc-editor.org/rfc/rfc8288#appendix-B> (that RFC appears to be
+          # silent about multiple "next" links, so just use the first one and ignore any additional
+          # ones, in the general spirit of being lenient):
+          return nil if link_header.nil?
+          field_value = link_header.clone
+          until field_value.empty?
+            # The following ignores any junk preceding the next <...> link URL:
+            m = field_value.match(/<(.*)>/)
+            break unless m
+            target_string = m[1]
+            field_value = m.post_match
+            params = parse_parameters(field_value)
+            if params[:has_next_rel]
+              # To keep it simple, ignore a link with an (unlikely) anchor parameter; but the RFC
+              # mandates that we "MUST NOT process the link without applying the anchor", so just raise
+              # an exception in that (unlikely) case:
+              fail "anchor not supported" if params[:has_anchor]
+              return target_string
+            end
+          end
+          nil
+        end
+
+        def docker_search
+          request_params = {
+            method: :get,
+            headers: { accept: :json },
+            url: "#{@uri}v1/search?q=#{@search}"
+          }
+
+          request_params[:user] = @upstream_username if @upstream_username
+          request_params[:password] = @upstream_password if @upstream_password
+          request_params[:proxy] = proxy_uri if proxy
+
+          begin
+            results = RestClient::Request.execute(request_params)
+            JSON.parse(results)['results'].each do |result|
+              @found << result['name']
+            end
+          rescue
+            # Note: v2 endpoint does not support search
+            request_params[:url] = "#{@uri}v2/_catalog"
+            loop do
+              results = RestClient::Request.execute(request_params)
+              JSON.parse(results)['repositories'].each do |result|
+                @found << result
+              end
+              next_uri = get_next_link(results.headers[:link])
+              break if next_uri.nil?
+              request_params[:url] = URI(request_params[:url]).merge(next_uri).to_s
+            end
+          end
+          @found.sort!
+        end
+      end
+    end
+  end
+end