katello 3.9.1 → 3.10.0.rc1

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

@@ -3,8 +3,6 @@ module Actions
   module Katello
     module Repository
       class ImportUpload < Actions::EntryAction
-        middleware.use Actions::Middleware::KeepCurrentUser
-
         def plan(repository, upload_ids, options = {})
           action_subject(repository)
 

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module Repository
       class IndexContent < Actions::EntryAction
-        middleware.use Actions::Middleware::KeepCurrentUser
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         input_format do

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

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module Repository
       class IndexPackageGroups < Actions::EntryAction
-        middleware.use Actions::Middleware::KeepCurrentUser
-
         def plan(repository)
           plan_self(:user_id => ::User.current.id, :id => repository.id)
         end

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

@@ -0,0 +1,21 @@
+module Actions
+  module Katello
+    module Repository
+      class InstanceUpdate < Actions::EntryAction
+        middleware.use Actions::Middleware::KeepCurrentUser
+
+        def plan(repository)
+          action_subject repository
+          repository.save!
+          plan_action(::Actions::Pulp::Repository::Refresh, repository)
+          plan_self(:repository_id => repository.id)
+        end
+
+        def run
+          repository = ::Katello::Repository.find(input[:repository_id])
+          ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
+        end
+      end
+    end
+  end
+end

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

@@ -4,8 +4,6 @@ module Actions
       class RemoveContent < Actions::EntryAction
         include Dynflow::Action::WithSubPlans
 
-        middleware.use Actions::Middleware::KeepCurrentUser
-
         def plan(repository, content_units, options = {})
           sync_capsule = options.fetch(:sync_capsule, true)
           if repository.redhat?

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

@@ -4,7 +4,6 @@ module Actions
     module Repository
       class Sync < Actions::EntryAction
         include Helpers::Presenter
-        middleware.use Actions::Middleware::KeepCurrentUser
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         input_format do

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

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module Repository
       class Update < Actions::EntryAction
-        middleware.use Actions::Middleware::KeepCurrentUser
-
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance

data/app/lib/actions/katello/upstream_subscriptions/bind_entitlement.rb

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class BindEntitlement < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
-
         def run
           output[:response] = ::Katello::Resources::Candlepin::UpstreamConsumer
             .bind_entitlement(pool)

data/app/lib/actions/katello/upstream_subscriptions/bind_entitlements.rb

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class BindEntitlements < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
-
         def plan(pools = [])
           fail _("No pools were provided.") unless pools.any?
           fail _("Current organization is not set.") unless ::Organization.current

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlement.rb

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class RemoveEntitlement < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
         middleware.use Actions::Middleware::PropagateCandlepinErrors
 
         input_format do

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlements.rb

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class RemoveEntitlements < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
-
         def plan(pool_ids = [])
           ids = pool_ids.uniq.compact
           fail _("No pool IDs were provided.") if ids.blank?

data/app/lib/actions/katello/upstream_subscriptions/update_entitlement.rb

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class UpdateEntitlement < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
         middleware.use Actions::Middleware::PropagateCandlepinErrors
 
         input_format do

data/app/lib/actions/katello/upstream_subscriptions/update_entitlements.rb

@@ -2,8 +2,6 @@ module Actions
   module Katello
     module UpstreamSubscriptions
       class UpdateEntitlements < Actions::Base
-        middleware.use Actions::Middleware::KeepCurrentTaxonomies
-
         def plan(pools = [])
           fail _("No pools were provided.") if pools.blank?
           fail _("Current organization is not set.") unless ::Organization.current

data/app/lib/actions/pulp/abstract.rb

@@ -5,29 +5,28 @@ module Actions
       middleware.use Actions::Middleware::PulpServicesCheck
 
       def pulp_resources(capsule_id = nil)
-        capsule_id ||= input.try(:[], "capsule_id")
-        if capsule_id
-          capsule_content = ::Katello::CapsuleContent.new(smart_proxy(capsule_id))
-          capsule_content.pulp_server.resources
-        else
-          ::Katello.pulp_server.resources
-        end
+        capsule_content(capsule_id).resources
       end
 
       def pulp_extensions(capsule_id = nil)
+        capsule_content(capsule_id).extensions
+      end
+
+      def smart_proxy(id)
+        SmartProxy.unscoped.find(id)
+      end
+
+      private
+
+      def capsule_content(capsule_id = nil)
         capsule_id ||= input["capsule_id"]
         if capsule_id
           capsule_content = ::Katello::CapsuleContent.new(SmartProxy.unscoped.find(capsule_id))
-          capsule_content.pulp_server.extensions
+          capsule_content.pulp_server
         else
-          ::Katello.pulp_server.extensions
+          ::Katello.pulp_server
         end
       end
-
-      def smart_proxy(capsule_id = nil)
-        smart_proxy = capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.default_capsule
-        smart_proxy
-      end
     end
   end
 end

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

@@ -5,227 +5,29 @@ module Actions
         include Helpers::Presenter
 
         input_format do
-          param :content_type
-          param :pulp_id
-          param :name
-          param :feed
-          param :ssl_ca_cert
-          param :ssl_client_cert
-          param :ssl_client_key
-          param :unprotected
-          param :checksum_type
-          param :path
-          param :with_importer
-          param :docker_upstream_name
-          param :docker_tags_whitelist
-          param :download_policy
+          param :repository_id
           param :capsule_id
-          param :mirror_on_sync
-          param :ssl_validation
-          param :upstream_username
-          param :upstream_password
-          param :ostree_upstream_sync_depth
-          param :ostree_publish_depth
-          param :deb_releases
-          param :deb_architectures
-          param :deb_components
-          param :ignorable_content
         end
 
-        def run
-          output[:response] = pulp_extensions.repository.
-              create_with_importer_and_distributors(input[:pulp_id],
-                                                    importer,
-                                                    distributors,
-                                                    display_name: input[:name])
-        rescue RestClient::Conflict
-          Rails.logger.warn("Tried to add repository #{input[:pulp_id]} that already exists.")
-          []
-        end
-
-        def importer
-          case input[:content_type]
-          when ::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE
-            yum_or_iso_importer
-          when ::Katello::Repository::PUPPET_TYPE
-            puppet_importer
-          when ::Katello::Repository::DOCKER_TYPE
-            docker_importer
-          when ::Katello::Repository::OSTREE_TYPE
-            ostree_importer
-          when ::Katello::Repository::DEB_TYPE
-            deb_importer
+        def plan(repository, smart_proxy = SmartProxy.pulp_master!)
+          if repository.is_a?(::Katello::ContentViewPuppetEnvironment)
+            plan_self(:content_view_puppet_environment_id => repository.id, :capsule_id => smart_proxy.id)
           else
-            fail _("Unexpected repo type %s") % input[:content_type]
-          end
-        end
-
-        def yum_or_iso_importer
-          importer = case input[:content_type]
-                     when ::Katello::Repository::YUM_TYPE
-                       Runcible::Models::YumImporter.new
-                     when ::Katello::Repository::FILE_TYPE
-                       Runcible::Models::IsoImporter.new
-                     end
-          importer.feed            = input[:feed]
-          importer.proxy_host      = input[:proxy_host]
-          importer.ssl_ca_cert     = input[:ssl_ca_cert]
-          importer.ssl_client_cert = input[:ssl_client_cert]
-          importer.ssl_client_key  = input[:ssl_client_key]
-          importer.ssl_validation  = input[:ssl_validation]
-          importer.download_policy = input[:download_policy] if input[:content_type] == ::Katello::Repository::YUM_TYPE
-          importer.remove_missing  = input[:mirror_on_sync] if input[:content_type] == ::Katello::Repository::YUM_TYPE
-          importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
-          importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
-          importer.type_skip_list = input[:ignorable_content] if input[:ignorable_content]
-          importer
-        end
-
-        def ostree_importer
-          importer = Runcible::Models::OstreeImporter.new
-          importer.feed            = input[:feed]
-          importer.proxy_host      = input[:proxy_host]
-          importer.ssl_ca_cert     = input[:ssl_ca_cert]
-          importer.ssl_client_cert = input[:ssl_client_cert]
-          importer.ssl_client_key  = input[:ssl_client_key]
-          importer.ssl_validation  = input[:ssl_validation]
-          importer.depth           = input[:ostree_upstream_sync_depth]
-          importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
-          importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
-          importer
-        end
-
-        def puppet_importer
-          importer = Runcible::Models::PuppetImporter.new
-          importer.feed            = input[:feed]
-          importer.proxy_host      = input[:proxy_host]
-          importer.ssl_ca_cert     = input[:ssl_ca_cert]
-          importer.ssl_client_cert = input[:ssl_client_cert]
-          importer.ssl_client_key  = input[:ssl_client_key]
-          importer.ssl_validation  = input[:ssl_validation]
-          importer.remove_missing  = input[:mirror_on_sync]
-          importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
-          importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
-          importer
-        end
-
-        def docker_importer
-          importer = Runcible::Models::DockerImporter.new
-          importer.proxy_host      = input[:proxy_host]
-          importer.upstream_name   = input[:docker_upstream_name] if input[:docker_upstream_name]
-          importer.tags            = input[:docker_tags_whitelist] if input[:docker_tags_whitelist]
-          importer.feed            = input[:feed]
-          importer.enable_v1       = false
-          importer.ssl_validation  = input[:ssl_validation]
-          importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
-          importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
-          importer
-        end
-
-        def deb_importer
-          Runcible::Models::DebImporter.new.tap do |importer|
-            importer.feed = input[:feed]
-            importer.releases = input[:deb_releases] if input[:deb_releases]
-            importer.architectures = input[:deb_architectures] if input[:deb_architectures]
-            importer.components = input[:deb_components] if input[:deb_components]
-            importer.ssl_validation = input[:ssl_validation]
-            importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
-            importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
+            plan_self(:repository_id => repository.id, :capsule_id => smart_proxy.id)
           end
         end
 
-        def distributors
-          case input[:content_type]
-          when ::Katello::Repository::YUM_TYPE
-            distributors = [yum_distributor, export_distributor]
-            distributors << yum_clone_distributor unless input[:capsule_id]
-          when ::Katello::Repository::FILE_TYPE
-            distributors = [iso_distributor]
-          when ::Katello::Repository::PUPPET_TYPE
-            distributors = input[:path].blank? ? [] : [puppet_install_distributor]
-            distributors << puppet_distributor
-          when ::Katello::Repository::DOCKER_TYPE
-            distributors = [docker_distributor]
-          when ::Katello::Repository::OSTREE_TYPE
-            distributors = [ostree_distributor]
-          when ::Katello::Repository::DEB_TYPE
-            distributors = [deb_distributor]
+        def run
+          if input[:repository_id]
+            repo = ::Katello::Repository.find(input[:repository_id])
           else
-            fail _("Unexpected repo type %s") % input[:content_type]
+            repo = ::Katello::ContentViewPuppetEnvironment.find(input[:content_view_puppet_environment_id]).nonpersisted_repository
           end
 
-          distributors
-        end
-
-        def yum_distributor
-          yum_dist_options = { protected: true,
-                               id: input[:pulp_id],
-                               auto_publish: true }
-          yum_dist_options[:skip] = input[:ignorable_content] if input[:ignorable_content]
-          yum_dist_options[:checksum_type] = input[:checksum_type] if input[:checksum_type]
-          Runcible::Models::YumDistributor.new(input[:path],
-                                               input[:unprotected] || false,
-                                               true,
-                                               yum_dist_options)
-        end
-
-        def yum_clone_distributor
-          Runcible::Models::YumCloneDistributor.new(id: "#{input[:pulp_id]}_clone",
-                                                    destination_distributor_id: input[:pulp_id])
-        end
-
-        def iso_distributor
-          options = { auto_publish: true }
-          Runcible::Models::IsoDistributor.new(input[:path],
-                                               input[:unprotected] || true,
-                                               true,
-                                               options)
-        end
-
-        def puppet_distributor
-          options = { id: "#{input[:pulp_id]}_puppet", auto_publish: true }
-          Runcible::Models::PuppetDistributor.new(nil,
-                                                  input[:unprotected] || false,
-                                                  true,
-                                                  options)
-        end
-
-        def puppet_install_distributor
-          Runcible::Models::PuppetInstallDistributor.new(input[:path],
-                                                         id: input[:pulp_id],
-                                                         auto_publish: true)
-        end
-
-        def docker_distributor
-          options = { protected: !input[:unprotected] || false,
-                      id: input[:pulp_id],
-                      auto_publish: true,
-                      repo_registry_id: input[:repo_registry_id]}
-          Runcible::Models::DockerDistributor.new(options)
-        end
-
-        def export_distributor
-          # "false, false" means "no http export, no https export". We only
-          # export to a directory.
-          Runcible::Models::ExportDistributor.new(false, false, input[:path])
-        end
-
-        def ostree_distributor
-          options = { id: input[:pulp_id],
-                      relative_path: input[:path],
-                      auto_publish: true }
-          options[:depth] = input[:ostree_publish_depth] if input[:ostree_publish_depth]
-          Runcible::Models::OstreeDistributor.new(options)
-        end
-
-        def deb_distributor
-          deb_dist_options = { id: input[:pulp_id],
-                               auto_publish: true }
-          deb_dist_options[:checksum_type] = input[:checksum_type] if input[:checksum_type]
-          Runcible::Models::DebDistributor.new(input[:path],
-                                               input[:unprotected] || false,
-                                               true,
-                                               deb_dist_options)
+          output[:response] = repo.backend_service(smart_proxy(input[:capsule_id])).create
+        rescue RestClient::Conflict
+          Rails.logger.warn("Tried to add repository #{input[:pulp_id]} that already exists.")
+          []
         end
       end
     end

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

@@ -4,24 +4,10 @@ module Actions
       class CreateInPlan < Create
         alias_method :perform_run, :run
 
-        def plan(input)
-          plan_self(input)
-          pulp_extensions.repository.create_with_importer_and_distributors(input[:pulp_id],
-                                                                           importer,
-                                                                           distributors,
-                                                                           display_name: input[:name])
-        rescue => e
-          raise e.try(:http_body) ? error_message(e.http_body) || e : e
-        end
-
-        def error_message(body)
-          JSON.parse(body)['error_message']
-        rescue JSON::ParserError
-          nil
-        end
-
-        def run
-          self.output = input
+        def plan(repository)
+          input[:response] = repository.backend_service(SmartProxy.pulp_master).create
+        rescue RestClient::Conflict
+          Rails.logger.warn("Tried to add repository #{input[:pulp_id]} that already exists.")
         end
       end
     end