katello 3.5.2 → 3.6.0.rc1

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

@@ -22,7 +22,10 @@ module Actions
             end
 
             if repository.yum?
-              plan_action(Repository::CloneYumContent, repository, clone, [], false,
+              plan_action(Repository::CloneYumMetadata, repository, clone,
+                          :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
+            elsif repository.deb?
+              plan_action(Repository::CloneDebContent, repository, clone, [], false,
                           :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
             elsif repository.docker?
               plan_action(Repository::CloneDockerContent, repository, clone, [])

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

@@ -15,16 +15,25 @@ module Actions
           sequence do
             plan_action(Repository::Create, new_repository, true, false)
 
-            repositories.each do |repository|
-              if new_repository.yum?
-                plan_action(Repository::CloneYumContent, repository, new_repository, filters, !incremental,
-                            :generate_metadata => !incremental, :index_content => !incremental, :simple_clone => incremental)
-              elsif new_repository.docker?
-                plan_action(Repository::CloneDockerContent, repository, new_repository, filters)
-              elsif new_repository.ostree?
-                plan_action(Repository::CloneOstreeContent, repository, new_repository)
-              elsif new_repository.file?
-                plan_action(Repository::CloneFileContent, repository, new_repository)
+            if new_repository.link?
+              fail "Cannot clone metadata if more than one repository" if repositories.count > 1
+              plan_action(Repository::CloneYumMetadata, repositories[0], new_repository,
+                                                            :force_yum_metadata_regeneration => true)
+            else
+              repositories.each do |repository|
+                if new_repository.yum?
+                  plan_action(Repository::CloneYumContent, repository, new_repository, filters, !incremental,
+                              :generate_metadata => !incremental, :index_content => !incremental, :simple_clone => incremental)
+                elsif new_repository.deb?
+                  plan_action(Repository::CloneDebContent, repository, new_repository, filters, !incremental,
+                              :generate_metadata => !incremental, :index_content => !incremental, :simple_clone => incremental)
+                elsif new_repository.docker?
+                  plan_action(Repository::CloneDockerContent, repository, new_repository, filters)
+                elsif new_repository.ostree?
+                  plan_action(Repository::CloneOstreeContent, repository, new_repository)
+                elsif new_repository.file?
+                  plan_action(Repository::CloneFileContent, repository, new_repository)
+                end
               end
             end
           end

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

@@ -20,6 +20,8 @@ module Actions
           end
 
           sequence do
+            plan_copy(Pulp::Repository::CopySrpm, source_repo, target_repo)
+
             if filters.empty? || copy_clauses
               plan_copy(Pulp::Repository::CopyRpm, source_repo, target_repo, copy_clauses)
               process_errata_and_groups = true

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

@@ -7,8 +7,7 @@ module Actions
             # Check for matching content before indexing happens, the content in pulp is
             # actually updated, but it is not reflected in the database yet.
             output = {}
-            if !target_repo.previous_changes.include?(:unprotected) &&
-                target_repo.environment && !options[:force_yum_metadata_regeneration]
+            if target_repo.environment && !options[:force_yum_metadata_regeneration]
               output = plan_action(Katello::Repository::CheckMatchingContent,
                                    :source_repo_id => source_repo.id,
                                    :target_repo_id => target_repo.id).output

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

@@ -12,7 +12,7 @@ module Actions
 
           create_action = plan_create ? Actions::Pulp::Repository::CreateInPlan : Actions::Pulp::Repository::Create
           sequence do
-            certs = repository.importer_ssl_options
+            certs = repository.importer_connection_options
             create_action = plan_action(create_action,
                                         content_type: repository.content_type,
                                         pulp_id: repository.pulp_id,
@@ -28,12 +28,16 @@ module Actions
                                         download_policy: repository.download_policy,
                                         ostree_upstream_sync_depth: repository.compute_ostree_upstream_sync_depth,
                                         ostree_publish_depth: repository.compute_ostree_upstream_sync_depth,
+                                        deb_releases: repository.deb_releases,
+                                        deb_components: repository.deb_components,
+                                        deb_architectures: repository.deb_architectures,
                                         with_importer: true,
                                         mirror_on_sync: repository.mirror_on_sync?,
                                         ssl_validation: certs[:ssl_validation],
                                         upstream_username: repository.upstream_username,
                                         upstream_password: repository.upstream_password,
-                                        repo_registry_id: repository.container_repository_name)
+                                        repo_registry_id: repository.container_repository_name,
+                                        proxy_host: repository.proxy_host_value)
 
             return if create_action.error
 

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

@@ -15,7 +15,7 @@ module Actions
               options.fetch(:organization_destroy, false)
           action_subject(repository)
 
-          if !planned_destroy && !repository.assert_deletable
+          if !planned_destroy && !repository.destroyable?
             # The repository is going to be deleted in finalize, but it cannot be deleted.
             # Stop now and inform the user.
             fail repository.errors.messages.values.join("\n")

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

@@ -39,6 +39,7 @@ module Actions
           export_directory = File.join(EXPORT_OUTPUT_BASEDIR, group_id)
 
           sequence do
+            copy_units(repos)
             plan_action(Pulp::RepositoryGroup::Create, :id => group_id,
                                                        :pulp_ids => repo_pulp_ids)
             plan_action(Pulp::RepositoryGroup::Export, :id => group_id,
@@ -64,6 +65,20 @@ module Actions
           _("Export")
         end
 
+        def copy_units(repos)
+          concurrence do
+            repos.each do |repo|
+              sequence do
+                if repo.link?
+                  plan_action(Katello::Repository::Clear, repo)
+                  plan_action(Katello::Repository::CloneYumContent, repo.target_repository, repo, [], false,
+                              :generate_metadata => false, :index_content => false)
+                end
+              end
+            end
+          end
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

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

@@ -0,0 +1,49 @@
+module Actions
+  module Katello
+    module Repository
+      class FetchPxeFiles < Actions::EntryAction
+        middleware.use Actions::Middleware::KeepCurrentUser
+
+        input_format do
+          param :id, Integer
+          param :capsule_id, Integer
+        end
+
+        def run
+          repository = ::Katello::Repository.find(input[:id])
+          if repository.distribution_bootable? &&
+             repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+
+            capsule = if input[:capsule_id].present?
+                        SmartProxy.unscoped.find(input[:capsule_id])
+                      else
+                        SmartProxy.default_capsule!
+                      end
+            repo_path = repository.full_path(capsule, true).chomp("/")
+
+            os = Redhat.find_or_create_operating_system(repository)
+
+            ueber_cert = ::Cert::Certs.ueber_cert(repository.organization)
+            cert = OpenSSL::X509::Certificate.new(ueber_cert[:cert])
+            key = OpenSSL::PKey::RSA.new(ueber_cert[:key])
+
+            Redhat::PXEFILES.each_key do |pxe_file|
+              fetch("#{repo_path}/#{os.url_for_boot(pxe_file)}", cert, key)
+            end
+          end
+        end
+
+        def fetch(url, cert, key)
+          RestClient::Request.execute(:method => :get,
+                                      :url => url,
+                                      :timeout => SETTINGS[:katello][:rest_client_timeout],
+                                      :ssl_client_cert => cert,
+                                      :ssl_client_key => key)
+          Rails.logger.info("retrieved #{url}")
+        rescue StandardError => e
+          Rails.logger.warn("Exception -> #{e.inspect} when retrieving #{url}")
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,8 @@ module Actions
             ::Katello::DockerManifest.import_for_repository(repo)
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
+          elsif repo.deb?
+            ::Katello::Deb.import_all(unit_ids)
           else
             ::Katello::Rpm.import_all(unit_ids)
           end

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

@@ -4,8 +4,10 @@ module Actions
       class MetadataGenerate < Actions::Base
         def plan(repository, options = {})
           dependency = options.fetch(:dependency, nil)
-          source_repository = options.fetch(:source_repository, nil)
           force = options.fetch(:force, false)
+          source_repository = options.fetch(:source_repository, nil)
+
+          source_repository ||= repository.target_repository if repository.link?
 
           distributors(repository, source_repository).each do |distributor|
             plan_action(Pulp::Repository::DistributorPublish,
@@ -46,6 +48,8 @@ module Actions
             [Runcible::Models::DockerDistributor]
           when ::Katello::Repository::OSTREE_TYPE
             [Runcible::Models::OstreeDistributor]
+          when ::Katello::Repository::DEB_TYPE
+            [Runcible::Models::DebDistributor]
           end
         end
       end

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

@@ -26,6 +26,8 @@ module Actions
                           Pulp::Repository::RemoveDockerManifest
                         when ::Katello::Repository::FILE_TYPE
                           Pulp::Repository::RemoveFile
+                        when ::Katello::Repository::DEB_TYPE
+                          Pulp::Repository::RemoveDeb
                         end
 
           uuids = content_units.map(&:uuid)

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

@@ -15,7 +15,8 @@ module Actions
         # @param repo
         # @param pulp_sync_task_id in case the sync was triggered outside
         #   of Katello and we just need to finish the rest of the orchestration
-        def plan(repo, pulp_sync_task_id = nil, options = {}) # rubocop:disable MethodLength
+        # rubocop:disable MethodLength
+        def plan(repo, pulp_sync_task_id = nil, options = {})
           action_subject(repo)
 
           source_url = options.fetch(:source_url, nil)
@@ -34,15 +35,13 @@ module Actions
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
           sequence do
-            # clear yum metadata if validate_contents is on (to avoid metadata corruption issues)
-            plan_action(Pulp::Repository::RemoveYumMetadataFile, :pulp_id => repo.pulp_id) if validate_contents
-
             sync_args = {:pulp_id => repo.pulp_id, :task_id => pulp_sync_task_id, :source_url => source_url, :options => pulp_sync_options}
             output = plan_action(Pulp::Repository::Sync, sync_args).output
 
             contents_changed = skip_metadata_check || output[:contents_changed]
             plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed, :full_index => skip_metadata_check)
             plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
+            plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
             plan_action(Katello::Repository::CorrectChecksum, repo)
             concurrence do
               plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents
@@ -62,9 +61,9 @@ module Actions
         end
 
         def humanized_name
-          if input[:validate_contents]
+          if input && input[:validate_contents]
             _("Synchronize: Validate Content")
-          elsif input[:skip_metadata_check]
+          elsif input && input[:skip_metadata_check]
             _("Synchronize: Skip Metadata Check")
           else
             _("Synchronize")

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

@@ -3,7 +3,6 @@ module Actions
     module Repository
       class Update < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
-
         def plan(repository, repo_params)
           action_subject repository
           repository = repository.reload
@@ -11,15 +10,26 @@ module Actions
           repository.update_attributes!(repo_params)
 
           if update_content?(repository)
+            content_url = ::Katello::Glue::Pulp::Repos.custom_content_path(repository.product, repository.label)
+            katello_content_id = repository.product.product_content_by_id(repository.content_id).content_id
+            content = ::Katello::Content.find(katello_content_id)
+
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
                         :owner => repository.organization.label,
                         :content_id => repository.content_id,
-                        :name => repository.content.name,
-                        :content_url => ::Katello::Glue::Pulp::Repos.custom_content_path(repository.product, repository.label),
+                        :name => content.name,
+                        :content_url => content_url,
                         :gpg_key_url => repository.yum_gpg_key_url,
-                        :label => repository.content.label,
+                        :label => content.label,
                         :type => repository.content_type,
                         :arches => repository.arch == "noarch" ? nil : repository.arch)
+
+            content.update_attributes!(name: content.name,
+                                       content_url: content_url,
+                                       content_type: repository.content_type,
+                                       label: content.label,
+                                       gpg_url: repository.yum_gpg_key_url)
+
           end
 
           if SETTINGS[:katello][:use_pulp] && repository.pulp_update_needed?

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

@@ -5,7 +5,6 @@ module Actions
         def plan(repository, params)
           action_subject(repository)
           unit_key = {"repo_id": repository.pulp_id, "id": params[:name].parameterize.underscore}
-          params = params.slice(:name, :description, :user_visible, :mandatory_package_names, :optional_package_names, :conditional_package_names, :default_package_names)
 
           sequence do
             upload_request = plan_action(Pulp::Repository::CreateUploadRequest)

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

@@ -22,15 +22,15 @@ module Actions
         private
 
         def repository_mapper(product, content, substitutions, registry_name)
-          if content.type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-            ::Katello::Candlepin::Content::DockerRepositoryMapper.new(product,
-                                                                content,
-                                                                registry_name)
+          if content.content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
+            ::Katello::Candlepin::DockerRepositoryMapper.new(product,
+                                                             content,
+                                                             registry_name)
 
           else
-            ::Katello::Candlepin::Content::RepositoryMapper.new(product,
-                                                                content,
-                                                                substitutions)
+            ::Katello::Candlepin::RepositoryMapper.new(product,
+                                                       content,
+                                                       substitutions)
           end
         end
       end

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

@@ -15,20 +15,30 @@ module Actions
           repository = mapper.build_repository
           plan_action(Repository::Create, repository, false, true)
           action_subject(repository)
+          plan_self
+        end
+
+        def run
+          repo = ::Katello::Repository.find(input[:repository][:id])
+          output[:repository] = {
+            :name => repo.name,
+            :id => repo.id,
+            :content_type => repo.content_type
+          }
         end
 
         private
 
         def repository_mapper(product, content, substituions, registry_name)
-          if content.type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-            ::Katello::Candlepin::Content::DockerRepositoryMapper.new(product,
-                                                                content,
-                                                                registry_name)
+          if content.content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
+            ::Katello::Candlepin::DockerRepositoryMapper.new(product,
+                                                             content,
+                                                             registry_name)
 
           else
-            ::Katello::Candlepin::Content::RepositoryMapper.new(product,
-                                                                content,
-                                                                substituions)
+            ::Katello::Candlepin::RepositoryMapper.new(product,
+                                                       content,
+                                                       substituions)
           end
         end
       end

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

@@ -17,9 +17,7 @@ module Actions
         end
 
         def plan(product, content_id)
-          prod_content = product.product_content_by_id(content_id).content
-
-          plan_self(product_id:  product.id, content_id: prod_content.id)
+          plan_self(product_id: product.id, content_id: content_id)
         end
 
         def run
@@ -29,12 +27,12 @@ module Actions
         private
 
         def fetch_results
-          if content.type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
+          if content.content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
             prepare_results_docker_content
           else
             substitutor = cdn_var_substitutor
             return [] unless substitutor
-            substitutor.substitute_vars(content.contentUrl).map do |path_with_substitutions|
+            substitutor.substitute_vars(content.content_url).map do |path_with_substitutions|
               prepare_result(path_with_substitutions.substitutions, path_with_substitutions.path)
             end
           end
@@ -46,9 +44,9 @@ module Actions
         end
 
         def prepare_results_docker_content
-          registries = product.cdn_resource.get_docker_registries(content.contentUrl)
+          registries = product.cdn_resource.get_docker_registries(content.content_url)
           registries.map do |registry|
-            mapper = ::Katello::Candlepin::Content::DockerRepositoryMapper.new(product,
+            mapper = ::Katello::Candlepin::DockerRepositoryMapper.new(product,
                                                                 content,
                                                                 registry['name'])
             mapper.registries = registries
@@ -98,9 +96,9 @@ module Actions
         end
 
         def repository_mapper(substitutions)
-          ::Katello::Candlepin::Content::RepositoryMapper.new(product,
-                                                              content,
-                                                              substitutions)
+          ::Katello::Candlepin::RepositoryMapper.new(product,
+                                                     content,
+                                                     substitutions)
         end
 
         def cdn_url

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

@@ -34,7 +34,7 @@ module Actions
           messages = []
           tasks.each do |pulp_task|
             if pulp_task[:result] && pulp_task[:result][:details]
-              pulp_task[:result][:details].each do |_content_type, result|
+              pulp_task[:result][:details].each_value do |result|
                 unless result[:succeeded]
                   messages << result[:details][:message]
                 end

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

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp
+    module Repository
+      class CopyDeb < Pulp::Repository::AbstractCopyContent
+        def content_extension
+          pulp_extensions.deb
+        end
+
+        def criteria
+          super.merge(fields: ::Katello::Pulp::Deb::PULP_SELECT_FIELDS)
+        end
+      end
+    end
+  end
+end