katello 4.0.3 → 4.1.0.rc1

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -12,6 +12,7 @@ module Katello
         before_action :find_content_view_version, :only => [:index, :auto_complete_search]
         before_action :find_filter, :find_filter_rule, :only => [:index, :auto_complete_search]
         before_action :find_content_resource, :only => [:show]
+        before_action :check_show_all_and_available_params, only: [:index]
       end
 
       extend ::Apipie::DSL::Concern
@@ -27,6 +28,7 @@ module Katello
       param :repository_id, :number, :desc => N_("repository identifier")
       param :environment_id, :number, :desc => N_("environment identifier")
       param :ids, Array, :desc => N_("ids to filter content by")
+      param :include_filter_ids, :bool, desc: N_("Includes associated content view filter ids in response")
       param_group :search, ::Katello::Api::V2::ApiController
       def index
         sort_by, sort_order, options = sort_options
@@ -70,7 +72,9 @@ module Katello
       end
 
       param :available_for, :string, :desc => N_("Return content that can be added to the specified object.  The values 'content_view_version' and 'content_view_filter are supported.")
-      param :filterId, :integer, :desc => N_("Content View Filter id")
+      param :show_all_for, :bool,
+            :desc => N_("Returns content that can be both added and is currently added to the object. The value 'content_view_filter' is supported")
+      param :filterId, :integer, :desc => N_("Content View Filter id"), deprecated: true
       def index_relation
         if @version && params[:available_for] == "content_view_version" && self.respond_to?(:available_for_content_view_version)
           collection = self.available_for_content_view_version(@version)
@@ -81,19 +85,7 @@ module Katello
 
         collection = filter_by_repos(repos, collection)
         collection = filter_by_ids(params[:ids], collection) if params[:ids]
-
-        @filter = ContentViewFilter.find(params[:filterId]) if params[:filterId]
-        if params[:available_for] == "content_view_filter" && self.respond_to?(:available_for_content_view_filter)
-          collection = self.available_for_content_view_filter(@filter, collection) if @filter
-        else
-          # Filtering by the CV filter rule makes filtering by the CV filter redundant, keeping these
-          # exclusive to keep the queries simple.
-          if @filter_rule
-            collection = filter_by_content_view_filter_rule(@filter_rule, collection)
-          elsif @filter
-            collection = filter_by_content_view_filter(@filter, collection)
-          end
-        end
+        collection = handle_cv_filter(collection, @filter, @filter_rule, params) if @filter || @filter_rule
 
         collection = self.custom_index_relation(collection) if self.respond_to?(:custom_index_relation)
         collection
@@ -127,11 +119,7 @@ module Katello
         repos = Repository.readable
         repos = repos.where(:id => @repo) if @repo
         repos = repos.where(:id => Repository.readable.in_organization(@organization)) if @organization
-        if @environment && (@environment.library? || resource_class != Katello::PuppetModule)
-          # if the environment is not library and this is for puppet modules,
-          # we can skip environment filter, as those would be associated to
-          # content view puppet environments and handled by the puppet modules
-          # controller.
+        if @environment&.library?
           repos = repos.where(:id => @environment.repositories)
         end
         repos
@@ -197,7 +185,7 @@ module Katello
 
       def find_filter
         # TODO: in v2.rb some routes use "filters", others use "content_view_filters"
-        filter_id = params[:content_view_filter_id] || params[:filter_id]
+        filter_id = params[:content_view_filter_id] || params[:filter_id] || params[:filterId]
 
         if filter_id
           scoped = ContentViewFilter.all
@@ -223,6 +211,12 @@ module Katello
         end
       end
 
+      def check_show_all_and_available_params
+        if params[:show_all_for] && params[:available_for]
+          fail HttpErrors::BadRequest, _("params 'show_all_for' and 'available_for' must be used independently")
+        end
+      end
+
       def resource_class
         "Katello::#{controller_name.classify}".constantize
       end
@@ -251,8 +245,6 @@ module Katello
           _("Source RPM")
         when "Katello::PackageGroup"
           _("Package Group")
-        when "Katello::PuppetModule"
-          _("Puppet Module")
         when "Katello::DockerManifest"
           _("Container Image Manifest")
         when "Katello::DockerMetaTag"
@@ -280,6 +272,23 @@ module Katello
             {content: resource_name, id: params[:id]}
         end
       end
+
+      def handle_cv_filter(collection, filter, filter_rule, params)
+        if params[:show_all_for] == "content_view_filter" && self.respond_to?(:all_for_content_view_filter)
+          collection = self.all_for_content_view_filter(filter, collection)
+        elsif params[:available_for] == "content_view_filter" && self.respond_to?(:available_for_content_view_filter)
+          collection = self.available_for_content_view_filter(filter, collection)
+        else
+          # Filtering by the CV filter rule makes filtering by the CV filter redundant, keeping these
+          # exclusive to keep the queries simple.
+          if filter_rule
+            collection = filter_by_content_view_filter_rule(filter_rule, collection)
+          elsif filter
+            collection = filter_by_content_view_filter(filter, collection)
+          end
+        end
+        collection
+      end
     end
   end
 end

data/app/controllers/katello/concerns/hosts_controller_extensions.rb

@@ -50,14 +50,6 @@ module Katello
           redirect_to(foreman_tasks_task_path(task.id))
         end
 
-        def puppet_environment_for_content_view
-          view = Katello::ContentView.find(params[:content_view_id])
-          environment = Katello::KTEnvironment.find(params[:lifecycle_environment_id])
-          version = view.version(environment)
-          cvpe = Katello::ContentViewPuppetEnvironment.where(:environment_id => environment, :content_view_version_id => version).first
-          render :json => cvpe.nil? ? nil : {:name => cvpe.puppet_environment.name, :id => cvpe.puppet_environment.id}
-        end
-
         def content_hosts
           respond_to do |format|
             format.csv do

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -30,7 +30,7 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
-              sync_task(::Actions::Katello::Organization::Create, @taxonomy)
+              ::Katello::OrganizationCreator.new(@taxonomy).create!
               @taxonomy.reload
               switch_taxonomy
               if @count_nil_hosts > 0

data/app/controllers/katello/concerns/registration_commands_controller_extensions.rb

@@ -0,0 +1,34 @@
+module Katello
+  module Concerns
+    module RegistrationCommandsControllerExtensions
+      extend ActiveSupport::Concern
+
+      def plugin_data
+        aks = ActivationKey.authorized(:view_activation_keys)
+                           .where(organization_id: registration_params[:organization_id])
+                           .order(:name)
+                           .map { |ak| { name: ak.name, lce: ak.environment&.name } }
+
+        lces = KTEnvironment.readable
+                            .where(organization_id: registration_params[:organization_id])
+                            .order(:name)
+
+        data = { activationKeys: aks, lifeCycleEnvironments: lces }
+
+        if registration_params[:hostgroup_id].present?
+          host_group = ::Hostgroup.authorized(:view_hostgroups).find(registration_params[:hostgroup_id])
+          data[:hostGroupActivationKeys] = host_group.params['kt_activation_keys']
+          data[:hostGroupEnvironment] = host_group.lifecycle_environment&.name
+        end
+
+        super.merge(data)
+      end
+
+      def registration_args
+        args = super
+        args['activation_keys'] = args['activation_keys'].join(',') if args['activation_keys']
+        args
+      end
+    end
+  end
+end

data/app/helpers/katello/katello_urls_helper.rb

@@ -2,10 +2,27 @@ require 'uri'
 
 module Katello
   module KatelloUrlsHelper
+    extend ApipieDSL::Module
+
+    apipie :class, 'Helper macros related to content to use within a template' do
+      name 'Content helpers'
+      sections only: %w[all reports provisioning jobs partition_tables]
+    end
+
+    apipie :method, 'Returns Foreman URL based on settings' do
+      optional :schema, String, desc: 'Optional URL schema'
+      returns String, desc: 'Foreman URL based on settings and schema if provided'
+    end
     def foreman_settings_url(schema = 'http')
       ::Setting[:foreman_url].sub(%r|^.*?:|, "#{schema}:")
     end
 
+    apipie :method, 'Returns subscription manager configuration URL' do
+      optional :host, 'Host::Managed', desc: "The host that will be making the request (URL will be of that host's smart proxy)", default: nil
+      optional :rpm, [true, false], desc: 'When true, the returned URL will lead to the configuration as an RPM package. When false, the URL will lead to the plain-text configuration script', default: true
+      keyword :hostname, String, desc: 'Override the hostname in the URL with the specified hostname', default: nil
+      returns String, desc: 'Subscription manager configuration URL based on provided arguments'
+    end
     def subscription_manager_configuration_url(host = nil, rpm = true, hostname: nil)
       prefix = if hostname
                  "http://#{hostname}"
@@ -20,6 +37,12 @@ module Katello
       "#{prefix}/pub/#{config}"
     end
 
+    apipie :method, 'Generates an absolute path to the file' do
+      required :content_path, String, desc: "Relative path to the file or it's name"
+      optional :schema, String, desc: 'Optional URL schema for the content source', default: 'http'
+      optional :content_type, String, desc: 'Content type', default: 'repos'
+      returns String, desc: 'Absolute path to a file'
+    end
     def repository_url(content_path, _content_type = nil, schema = 'http')
       return content_path if content_path =~ %r|^([\w\-\+]+)://|
       url = if @host.content_source

data/app/lib/actions/candlepin/owner/import.rb

@@ -1,7 +1,7 @@
 module Actions
   module Candlepin
     module Owner
-      class Import < Candlepin::Abstract
+      class Import < Candlepin::AbstractAsyncTask
         input_format do
           param :label
           param :path
@@ -9,9 +9,16 @@ module Actions
           param :upstream
         end
 
-        def run
+        def invoke_external_task
           options = input.slice(:force, :upstream)
-          output[:response] = ::Katello::Resources::Candlepin::Owner.import(input[:label], input[:path], options)
+          ::Katello::Resources::Candlepin::Owner.import(input[:label], input[:path], options)
+        end
+
+        def humanized_output
+          result_data = output[:task]&.[]('resultData')
+          return '' if result_data&.[]('status').blank?
+          "Candlepin job status: #{result_data['status']}\n
+          Message: #{result_data['statusMessage']}"
         end
       end
     end

data/app/lib/actions/candlepin/product/content_update.rb

@@ -22,7 +22,7 @@ module Actions
                      contentUrl: input[:content_url],
                      gpgUrl: input[:gpg_key_url] || '', #candlepin ignores nil
                      type: input[:type],
-                     arches: input[:arches],
+                     arches: input[:arches] || '',
                      requiredTags: input[:os_versions],
                      label: input[:label],
                      metadataExpire: 1,

data/app/lib/actions/foreman/environment/destroy.rb

@@ -5,13 +5,13 @@ module Actions
         def plan(environment)
           if environment.hosts.count > 0
             names = environment.hosts.limit(5).pluck(:name).join(', ')
-            fail _("The puppet environment %{name} is in use by %{count} Host(s) including %{names}") %
+            fail _("The environment %{name} is in use by %{count} Host(s) including %{names}") %
                      {:name => environment.name, :names => names, :count => environment.hosts.count}
           end
 
           if environment.hostgroups.count > 0
             names = environment.hostgroups.limit(5).pluck(:name).join(', ')
-            fail _("The puppet environment %{name} is in use by %{count} Host Group(s) including %{names}") %
+            fail _("The environment %{name} is in use by %{count} Host Group(s) including %{names}") %
                      {:name => environment.name, :names => names, :count => environment.hostgroups.count}
           end
 

data/app/lib/actions/katello/agent_action.rb

@@ -83,12 +83,7 @@ module Actions
         end
 
         unless history.finished?
-          # we could be processing the accept_timeout here
-          # only fail for finish_timeout unless the actual duration has elapsed
-          finish_limit = history.accepted_at + finish_timeout
-          if finish_limit < DateTime.now
-            fail _("Host did not finish content action in %s seconds.  The task has been cancelled.") % finish_timeout
-          end
+          fail _("Host did not finish content action in %s seconds.  The task has been cancelled.") % finish_timeout
         end
       end
 

data/app/lib/actions/katello/capsule_content/refresh_repos.rb

@@ -25,10 +25,6 @@ module Actions
           tasks = []
           environment = ::Katello::KTEnvironment.find_by(:id => input[:environment_id]) if input[:environment_id]
           repository = ::Katello::Repository.find_by(:id => input[:repository_id]) if input[:repository_id]
-          if repository.nil? && input[:repository_id]
-            repository = ::Katello::ContentViewPuppetEnvironment.find(input[:repository_id])
-            repository = repository.nonpersisted_repository
-          end
           content_view = ::Katello::ContentView.find_by(:id => input[:content_view_id]) if input[:content_view_id]
           smart_proxy = SmartProxy.unscoped.find(input[:smart_proxy_id])
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
@@ -39,9 +35,6 @@ module Actions
 
           list_of_repos_to_sync = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
           list_of_repos_to_sync.each do |repo|
-            if repo.is_a?(Katello::ContentViewPuppetEnvironment)
-              repo = repo.nonpersisted_repository
-            end
             next unless act_on_repo?(repo, smart_proxy)
 
             pulp_repo = repo.backend_service(smart_proxy)

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

@@ -39,7 +39,7 @@ module Actions
             end
 
             if smart_proxy.has_feature?(SmartProxy::PULP3_FEATURE)
-              plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
+              plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy)
               plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
             end
             plan_action(SyncCapsule, smart_proxy, refresh_options)

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -93,14 +93,13 @@ module Actions
             end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
-            puppet_envs = smart_proxy_helper.puppet_environments_available_to_capsule(environment, content_view)
             repositories_to_skip = []
             if skip_metatadata_check
               smart_proxy_helper.clear_smart_proxy_sync_histories repositories
             else
               repositories_to_skip = ::Katello::Repository.synced_on_capsule smart_proxy
             end
-            repositories - repositories_to_skip + puppet_envs
+            repositories - repositories_to_skip
           end
         end
 

data/app/lib/actions/katello/content_view/add_to_environment.rb

@@ -3,13 +3,15 @@ module Actions
     module ContentView
       class AddToEnvironment < Actions::Base
         def plan(content_view_version, environment)
-          content_view = content_view_version.content_view
-          if (cve = content_view.content_view_environment(environment))
-            content_view_version.content_view_environments << cve
-          else
-            cve = content_view.add_environment(environment, content_view_version)
-            plan_action(ContentView::EnvironmentCreate, cve)
-          end
+          cve = ::Katello::ContentViewManager.add_version_to_environment(
+            content_view_version: content_view_version,
+            environment: environment
+          )
+
+          ::Katello::ContentViewManager.create_candlepin_environment(
+            content_view_environment: cve
+          )
+
           content_view_version.save!
         end
       end

data/app/lib/actions/katello/content_view/incremental_updates.rb

@@ -25,7 +25,7 @@ module Actions
             end
 
             if composite_version_environments.any?
-              handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description, content[:puppet_module_ids])
+              handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description)
             end
 
             if hosts.any? && !content[:errata_ids].blank?
@@ -37,7 +37,7 @@ module Actions
           end
         end
 
-        def handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description, puppet_module_ids)
+        def handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description)
           concurrence do
             composite_version_environments.each do |version_environment|
               composite_version = version_environment[:content_view_version]
@@ -50,8 +50,7 @@ module Actions
               end
 
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
-                                   :new_components => new_components, :description => description,
-                                                           :content => {:puppet_module_ids => puppet_module_ids})
+                                   :new_components => new_components, :description => description)
               unless SmartProxy.pulp_primary.pulp3_repository_type_support?("yum")
                 output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
               end
@@ -84,7 +83,6 @@ module Actions
                 total_count[:errata_count] = added_units[:erratum].try(:count)
                 total_count[:modulemd_count] = added_units[:modulemd].try(:count)
                 total_count[:rpm_count] = added_units[:rpm].try(:count)
-                total_count[:puppet_module_count] = added_units[:puppet_module].try(:count)
               end
             end
           end
@@ -128,11 +126,6 @@ module Actions
             rpm = _(" %{package_count} Package(s)" % {:package_count => total_count[:rpm_count]})
             content << rpm
           end
-          if total_count[:puppet_module_count] && total_count[:puppet_module_count] > 0
-            puppet_module = _(" %{puppet_module_count} Puppet Module(s)" %
-                              {:puppet_module_count => total_count[:puppet_module_count]})
-            content << puppet_module
-          end
           content
         end
 

data/app/lib/actions/katello/content_view/presenters/incremental_updates_presenter.rb

@@ -6,8 +6,7 @@ module Actions
           HUMANIZED_TYPES = {
             ::Katello::Erratum::CONTENT_TYPE => "Errata",
             ::Katello::ModuleStream::CONTENT_TYPE => "Module Streams",
-            ::Katello::Rpm::CONTENT_TYPE => "Packages",
-            ::Katello::PuppetModule::CONTENT_TYPE => "Puppet Modules"
+            ::Katello::Rpm::CONTENT_TYPE => "Packages"
           }.freeze
 
           def humanized_output
@@ -26,7 +25,7 @@ module Actions
               if cvv
                 humanized_lines << "Content View: #{cvv.content_view.name} version #{cvv.version}"
                 humanized_lines << _("Added Content:")
-                [::Katello::Erratum, ::Katello::ModuleStream, ::Katello::Rpm, ::Katello::PuppetModule].each do |content_type|
+                [::Katello::Erratum, ::Katello::ModuleStream, ::Katello::Rpm].each do |content_type|
                   unless output[:added_units][content_type::CONTENT_TYPE].blank?
                     humanized_lines << "  #{HUMANIZED_TYPES[content_type::CONTENT_TYPE]}:"
                     humanized_lines += output[:added_units][content_type::CONTENT_TYPE].sort.map { |unit| "        #{unit}" }

data/app/lib/actions/katello/content_view/promote_to_environment.rb

@@ -13,15 +13,12 @@ module Actions
           sequence do
             plan_action(ContentView::AddToEnvironment, version, environment)
             concurrence do
-              version.archived_repos.non_puppet.each do |repository|
+              version.archived_repos.each do |repository|
                 sequence do
                   plan_action(Repository::CloneToEnvironment, repository, environment)
                 end
               end
 
-              plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => environment,
-                          :puppet_modules_present => version.promote_puppet_environment?)
-
               repos_to_delete(version, environment).each do |repo|
                 plan_action(Repository::Destroy, repo, :skip_environment_update => true)
               end

data/app/lib/actions/katello/content_view/publish.rb

@@ -48,24 +48,20 @@ module Actions
           sequence do
             plan_action(ContentView::AddToEnvironment, version, library) unless options[:skip_promotion]
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, version, source_repositories).repository_mapping
-
             # Split Pulp 3 Yum repos out of the repository_mapping.  Only Pulp 3 RPM plugin has multi repo copy support.
             separated_repo_map = separated_repo_mapping(repository_mapping)
 
-            if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
-                SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
-
-              if options[:importing]
-                handle_import(version, options.slice(:path, :metadata))
-              else
-                plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
-              end
+            if options[:importing]
+              handle_import(version, options.slice(:path, :metadata))
+            elsif separated_repo_map[:pulp3_yum].keys.flatten.present? &&
+              SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
+              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
             end
 
             concurrence do
               source_repositories.each do |repositories|
                 sequence do
-                  if repositories.present? && separated_repo_map[:other].keys.include?(repositories)
+                  if !options[:importing] && repositories.present? && separated_repo_map[:other].keys.include?(repositories)
                     plan_action(Repository::CloneToVersion, repositories, version, repository_mapping[repositories],
                                 :repos_units => options[:repos_units])
                   end
@@ -78,14 +74,6 @@ module Actions
               end
             end
 
-            if SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE)
-              has_modules = content_view.publish_puppet_environment?
-              plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
-              unless options[:skip_promotion]
-                plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
-                    :puppet_modules_present => has_modules)
-              end
-            end
             plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
             plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
             plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
@@ -147,14 +135,6 @@ module Actions
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
-        def content_view_version_id
-          input['content_view_version_id']
-        end
-
-        def content_view_version_name
-          input['content_view_version_name']
-        end
-
         private
 
         def include_other_components(override_components, content_view)
@@ -199,15 +179,25 @@ module Actions
         end
 
         def handle_import(version, path:, metadata:)
-          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
-          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
-          concurrence do
-            version.importable_repositories.pluck(:id).each do |id|
-              plan_action(Katello::Repository::IndexContent, id: id)
+          sequence do
+            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
+            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
+            concurrence do
+              version.importable_repositories.pluck(:id).each do |id|
+                plan_action(Katello::Repository::IndexContent, id: id)
+              end
             end
           end
         end
 
+        def content_view_version_id
+          input['content_view_version_id']
+        end
+
+        def content_view_version_name
+          input['content_view_version_name']
+        end
+
         apipie :class, "A class representing #{self} object" do
           desc 'This object is available as **@object** variable in
                 webhook templates when a corresponding event occures.

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

@@ -18,11 +18,6 @@ module Actions
                   plan_action(Repository::Destroy, repo, skip_environment_update: true)
                 end
               end
-
-              if (puppet_env = content_view.puppet_env(environment))
-                plan_action(Actions::Foreman::Environment::Destroy, puppet_env.puppet_environment) if puppet_env.puppet_environment
-                plan_action(ContentViewPuppetEnvironment::Destroy, puppet_env) unless organization_destroy
-              end
             end
             plan_action(Candlepin::Environment::Destroy, cp_id: cv_env.cp_id) unless organization_destroy
             plan_self(:id => cv_env.id)

data/app/lib/actions/katello/content_view_version/auto_create_products.rb

@@ -0,0 +1,22 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class AutoCreateProducts < Actions::Base
+        def plan(organization:, metadata:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableProducts.
+                      new(organization: organization,
+                          metadata: metadata)
+          helper.generate!
+          concurrence do
+            helper.creatable.each do |product|
+              plan_action(::Actions::Katello::Product::Create, product[:product], organization)
+            end
+            helper.updatable.each do |product|
+              plan_action(::Actions::Katello::Product::Update, product[:product], product[:options])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view_version/auto_create_repositories.rb

@@ -0,0 +1,22 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class AutoCreateRepositories < Actions::Base
+        def plan(organization:, metadata:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.
+                      new(organization: organization,
+                          metadata: metadata)
+          helper.generate!
+          sequence do
+            helper.creatable.each do |root|
+              plan_action(::Actions::Katello::Repository::CreateRoot, root[:repository])
+            end
+            helper.updatable.each do |root|
+              plan_action(::Actions::Katello::Repository::Update, root[:repository], root[:options])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,22 +8,12 @@ module Actions
           destroy_env_content = !options.fetch(:skip_destroy_env_content, false)
           repos = destroy_env_content ? version.repositories : version.archived_repos
 
-          puppet_envs = []
-          if destroy_env_content
-            puppet_envs = version.content_view_puppet_environments
-          elsif version.archive_puppet_environment
-            puppet_envs = [version.archive_puppet_environment]
-          end
-
           sequence do
             concurrence do
               repos.each do |repo|
                 repo_options = options.clone
                 plan_action(Repository::Destroy, repo, repo_options)
               end
-              puppet_envs.each do |cvpe|
-                plan_action(ContentViewPuppetEnvironment::Destroy, cvpe) unless version.default?
-              end
             end
           end