katello 3.8.1 → 3.9.0.rc1

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

@@ -5,6 +5,8 @@ module Actions
         # rubocop:disable MethodLength
         def plan(repository, clone = false, plan_create = false)
           repository.save!
+          root = repository.root
+
           action_subject(repository)
 
           org = repository.organization
@@ -18,16 +20,17 @@ module Actions
                                         pulp_id: repository.pulp_id,
                                         name: repository.name,
                                         docker_upstream_name: repository.docker_upstream_name,
+                                        docker_tags_whitelist: root.docker_tags_whitelist,
                                         feed: repository.url,
                                         ssl_ca_cert: certs[:ssl_ca_cert],
                                         ssl_client_cert: certs[:ssl_client_cert],
                                         ssl_client_key: certs[:ssl_client_key],
                                         unprotected: repository.unprotected,
-                                        checksum_type: repository.checksum_type,
+                                        checksum_type: repository.saved_checksum_type || repository.checksum_type,
                                         path: path,
                                         download_policy: repository.download_policy,
-                                        ostree_upstream_sync_depth: repository.compute_ostree_upstream_sync_depth,
-                                        ostree_publish_depth: repository.compute_ostree_upstream_sync_depth,
+                                        ostree_upstream_sync_depth: root.compute_ostree_upstream_sync_depth,
+                                        ostree_publish_depth: root.compute_ostree_upstream_sync_depth,
                                         deb_releases: repository.deb_releases,
                                         deb_components: repository.deb_components,
                                         deb_architectures: repository.deb_architectures,
@@ -49,16 +52,13 @@ module Actions
                 plan_action(ContentView::UpdateEnvironment, org.default_content_view,
                             org.library, repository.content_id)
               else
-                content_create = plan_action(Katello::Product::ContentCreate, repository)
+                content_create = plan_action(Katello::Product::ContentCreate, root)
                 plan_action(ContentView::UpdateEnvironment, org.default_content_view,
                             org.library, content_create.input[:content_id])
               end
             end
 
             concurrence do
-              if !clone && repository.product.sync_plan
-                plan_action(::Actions::Pulp::Repos::Update, repository.product)
-              end
               plan_self(:repository_id => repository.id, :clone => clone)
             end
           end

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

@@ -0,0 +1,22 @@
+module Actions
+  module Katello
+    module Repository
+      class CreateRoot < Actions::EntryAction
+        def plan(root)
+          root.save!
+          repository = ::Katello::Repository.new(:environment => root.organization.library,
+                                      :content_view_version => root.organization.library.default_content_view_version,
+                                      :root => root)
+          repository.relative_path = repository.custom_repo_path
+          repository.save!
+          action_subject(repository)
+          plan_action(::Actions::Katello::Repository::Create, repository, false, true)
+        end
+
+        def humanized_name
+          _("Create")
+        end
+      end
+    end
+  end
+end

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

@@ -24,11 +24,11 @@ module Actions
           plan_action(ContentViewPuppetModule::Destroy, repository) if repository.puppet?
           plan_action(Pulp::Repository::Destroy, pulp_id: repository.pulp_id)
           sequence do
-            repository.destroy! if planned_destroy
+            delete_record(repository) if planned_destroy
             if repository.redhat?
               handle_redhat_content(repository)
             else
-              handle_custom_content(repository) unless skip_environment_update
+              handle_custom_content(repository.root) unless skip_environment_update
             end
           end
 
@@ -38,14 +38,14 @@ module Actions
         def finalize
           unless input[:planned_destroy]
             repository = ::Katello::Repository.find(input[:repository][:id])
-            repository.destroy!
+            delete_record(repository)
           end
         end
 
-        def handle_custom_content(repository)
+        def handle_custom_content(root)
           #if this is the last instance of a custom repo, destroy the content
-          if repository.other_repos_with_same_product_and_content.empty?
-            plan_action(Product::ContentDestroy, repository)
+          if root.repositories.count == 1
+            plan_action(Product::ContentDestroy, root)
           end
         end
 
@@ -55,6 +55,11 @@ module Actions
           end
         end
 
+        def delete_record(repository)
+          repository.destroy!
+          repository.root.destroy! if repository.root.repositories.empty?
+        end
+
         def humanized_name
           _("Delete")
         end

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

@@ -9,14 +9,15 @@ module Actions
           param :content_type, String
           param :upstream_username, String
           param :upstream_password, String
+          param :search, String
         end
 
         output_format do
           param :repo_urls, array_of(String)
         end
 
-        def plan(url, content_type, upstream_username, upstream_password)
-          plan_self(url: url, content_type: content_type, upstream_username: upstream_username, upstream_password: upstream_password)
+        def plan(url, content_type, upstream_username, upstream_password, search)
+          plan_self(url: url, content_type: content_type, upstream_username: upstream_username, upstream_password: upstream_password, search: search)
         end
 
         def run(event = nil)
@@ -25,7 +26,8 @@ module Actions
           output[:to_follow] = output[:to_follow] || [input[:url]]
 
           repo_discovery = ::Katello::RepoDiscovery.new(input[:url], input[:content_type],
-                                                        input[:upstream_username], input[:upstream_password], proxy,
+                                                        input[:upstream_username], input[:upstream_password],
+                                                        input[:search], proxy,
                                                         output[:crawled], output[:repo_urls], output[:to_follow])
 
           match(event,

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

@@ -71,7 +71,7 @@ module Actions
               sequence do
                 if repo.link?
                   plan_action(Katello::Repository::Clear, repo)
-                  plan_action(Katello::Repository::CloneYumContent, repo.target_repository, repo, [], false,
+                  plan_action(Katello::Repository::CloneYumContent, repo.target_repository, repo, [], :purge_empty_units => false,
                               :generate_metadata => false, :index_content => false)
                 end
               end

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

@@ -11,37 +11,23 @@ module Actions
 
         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)
+          return unless needs_download?(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])
+          capsule = if input[:capsule_id].present?
+                      SmartProxy.unscoped.find(input[:capsule_id])
+                    else
+                      SmartProxy.default_capsule!
+                    end
 
-            Redhat::PXEFILES.each_key do |pxe_file|
-              fetch("#{repo_path}/#{os.url_for_boot(pxe_file)}", cert, key)
-            end
-          end
+          downloader = ::Katello::PxeFilesDownloader.new(repository, capsule)
+          downloader.download_files
         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}")
+        private
+
+        def needs_download?(repository)
+          repository.distribution_bootable? &&
+             repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
         end
       end
     end

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

@@ -0,0 +1,16 @@
+module Actions
+  module Katello
+    module Repository
+      class IndexModuleStreams < Actions::EntryAction
+        def plan(repository)
+          plan_self(:user_id => ::User.current.id, :id => repository.id)
+        end
+
+        def run
+          repo = ::Katello::Repository.find(input[:id])
+          ::Katello::ModuleStream.import_for_repository(repo)
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module Actions
         end
 
         def override_config(distributor_class, force)
-          if distributor_class == Runcible::Models::YumDistributor
+          if distributor_class == Runcible::Models::YumDistributor || distributor_class == Runcible::Models::YumCloneDistributor
             {:force_full => force}
           else
             {}

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

@@ -36,8 +36,6 @@ module Actions
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
           sequence do
-            plan_action(::Actions::Pulp::Repository::EnsureSyncNotification)
-
             # 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
 

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

@@ -3,47 +3,37 @@ module Actions
     module Repository
       class Update < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
-        # rubocop:disable MethodLength
-        def plan(repository, repo_params)
-          action_subject repository
-          repository = repository.reload
+
+        def plan(root, repo_params)
+          repository = root.library_instance
+          action_subject root.library_instance
+
           repo_params[:url] = nil if repo_params[:url] == ''
-          repository.update_attributes!(repo_params)
+          root.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)
+            content = root.content
 
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
                         :owner => repository.organization.label,
-                        :content_id => repository.content_id,
+                        :content_id => root.content_id,
                         :name => content.name,
-                        :content_url => content_url,
+                        :content_url => root.custom_content_path,
                         :gpg_key_url => repository.yum_gpg_key_url,
                         :label => content.label,
-                        :type => repository.content_type,
-                        :arches => repository.arch == "noarch" ? nil : repository.arch)
+                        :type => root.content_type,
+                        :arches => root.arch == "noarch" ? nil : root.arch)
 
             content.update_attributes!(name: content.name,
-                                       content_url: content_url,
+                                       content_url: root.custom_content_path,
                                        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?
-            plan_action(::Actions::Pulp::Repository::Refresh, repository)
-          end
-
-          if SETTINGS[:katello][:use_pulp] && (repository.previous_changes.key?('unprotected') ||
-              repository.previous_changes.key?('checksum_type') ||
-              repository.previous_changes.key?('container_repository_name'))
-            plan_self(:repository_id => repository.id)
-          end
+          plan_action(::Actions::Pulp::Repository::Refresh, repository) if root.pulp_update_needed?
+          plan_self(:repository_id => root.library_instance.id)
         end
-        # rubocop:enable MethodLength
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
@@ -53,10 +43,7 @@ module Actions
         private
 
         def update_content?(repository)
-          SETTINGS[:katello][:use_cp] &&
-            SETTINGS[:katello][:use_pulp] &&
-            repository.library_instance? &&
-            !repository.product.redhat?
+          repository.library_instance? && !repository.product.redhat?
         end
       end
     end

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

@@ -9,8 +9,7 @@ module Actions
         def plan(product, content, options)
           repository = repository_mapper(product,
                                          content,
-                                         options,
-                                         options[:registry_name]).find_repository
+                                         options).find_repository
           if repository
             action_subject(repository)
             plan_action(Repository::Destroy, repository, :planned_destroy => true)
@@ -21,17 +20,10 @@ module Actions
 
         private
 
-        def repository_mapper(product, content, substitutions, registry_name)
-          if content.content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-            ::Katello::Candlepin::DockerRepositoryMapper.new(product,
-                                                             content,
-                                                             registry_name)
-
-          else
-            ::Katello::Candlepin::RepositoryMapper.new(product,
-                                                       content,
-                                                       substitutions)
-          end
+        def repository_mapper(product, content, substitutions)
+          ::Katello::Candlepin::RepositoryMapper.new(product,
+                                                     content,
+                                                     substitutions)
         end
       end
     end

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

@@ -7,7 +7,9 @@ module Actions
         end
 
         def plan(product, content, options)
-          mapper = repository_mapper(product, content, options, options[:registry_name])
+          mapper = ::Katello::Candlepin::RepositoryMapper.new(product,
+                                                               content,
+                                                               options)
           mapper.validate!
           if mapper.find_repository
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
@@ -26,21 +28,6 @@ module Actions
             :content_type => repo.content_type
           }
         end
-
-        private
-
-        def repository_mapper(product, content, substituions, registry_name)
-          if content.content_type == ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
-            ::Katello::Candlepin::DockerRepositoryMapper.new(product,
-                                                             content,
-                                                             registry_name)
-
-          else
-            ::Katello::Candlepin::RepositoryMapper.new(product,
-                                                       content,
-                                                       substituions)
-          end
-        end
       end
     end
   end

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

@@ -27,14 +27,10 @@ module Actions
         private
 
         def fetch_results
-          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.content_url).map do |path_with_substitutions|
-              prepare_result(path_with_substitutions.substitutions, path_with_substitutions.path)
-            end
+          substitutor = cdn_var_substitutor
+          return [] unless substitutor
+          substitutor.substitute_vars(content.content_url).map do |path_with_substitutions|
+            prepare_result(path_with_substitutions.substitutions, path_with_substitutions.path)
           end
         end
 
@@ -43,30 +39,6 @@ module Actions
           cdn_resource.substitutor
         end
 
-        def prepare_results_docker_content
-          registries = product.cdn_resource.get_docker_registries(content.content_url)
-          registries.map do |registry|
-            mapper = ::Katello::Candlepin::DockerRepositoryMapper.new(product,
-                                                                content,
-                                                                registry['name'])
-            mapper.registries = registries
-            mapper.registry_repo = registry
-            repo = mapper.find_repository
-            unique_id = repo.try(:pulp_id) || SecureRandom.uuid
-
-            {
-              substitutions: {},
-              path:          mapper.feed_url,
-              repo_name:     mapper.name,
-              pulp_id:       unique_id,
-              registry_name: registry["name"],
-              enabled:       !repo.nil?,
-              promoted:      (!repo.nil? && repo.promoted?),
-              repository_id: repo.try(:id)
-            }
-          end
-        end
-
         def prepare_result(substitutions, _path)
           mapper = repository_mapper(substitutions)
           repo = mapper.find_repository

data/app/lib/actions/katello/sync_plan/run.rb

@@ -0,0 +1,37 @@
+module Actions
+  module Katello
+    module SyncPlan
+      class Run < Actions::EntryAction
+        include Actions::RecurringAction
+        def plan(sync_plan)
+          action_subject(sync_plan)
+          User.as_anonymous_admin do
+            fail _("No products in sync plan") unless sync_plan.products
+
+            syncable_products = sync_plan.products.syncable
+            syncable_roots = ::Katello::RootRepository.where(:product_id => syncable_products).has_url
+
+            fail _("No syncable repositories found for selected products and options.") if syncable_roots.empty?
+
+            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Sync,
+                        syncable_roots.map(&:library_instance))
+
+            plan_self(:sync_plan_name => sync_plan.name)
+          end
+        end
+
+        def humanized_name
+          if input.try(:[], :sync_plan_name)
+            _('Run Sync Plan %s') % (input[:sync_plan_name] || _('Unknown'))
+          else
+            _('Run Sync Plan')
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end