katello 4.18.0 → 4.19.0.rc1

data/app/controllers/katello/api/v2/host_subscriptions_controller.rb

@@ -2,7 +2,6 @@ module Katello
   class Api::V2::HostSubscriptionsController < Katello::Api::V2::ApiController
     include Katello::Concerns::Api::V2::ContentOverridesController
     before_action :find_host, :except => :create
-    before_action :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
     before_action :find_content_view_environment, :only => :create
     before_action :check_registration_services, :only => [:destroy, :create]
     before_action :find_content_overrides, :only => [:content_override]
@@ -17,10 +16,9 @@ module Katello
 
     def_param_group :subscription_facet_attributes do
       param :release_version, String, :desc => N_("Release version for this Host to use (7Server, 7.1, etc)")
-      param :autoheal, :bool, :desc => N_("Sets whether the Host will autoheal subscriptions upon checkin")
       param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
       param :purpose_role, String, :desc => N_("Sets the system purpose usage")
-      param :service_level, String, :desc => N_("Service level to be used for autoheal")
+      param :service_level, String, :desc => N_("Service level")
       param :hypervisor_guest_uuids, Array, :desc => N_("List of hypervisor guest uuids")
       param :installed_products_attributes, Array, :desc => N_("List of products installed on the host") do
         param_group :installed_products, Api::V2::HostSubscriptionsController
@@ -51,18 +49,6 @@ module Katello
       full_result_response(presenter.subscriptions)
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    def auto_attach
-      deprecate_entitlement_mode_endpoint
-      if @host.organization.simple_content_access?
-        fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Auto-attach is disabled")
-      end
-
-      sync_task(::Actions::Katello::Host::AutoAttachSubscriptions, @host)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
     api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def destroy
@@ -80,7 +66,7 @@ module Katello
       param_group :installed_products, ::Katello::Api::V2::HostSubscriptionsController
     end
     param :release_version, String, :desc => N_("Release version of the content host")
-    param :service_level, String, :desc => N_("A service level for auto-healing process, e.g. SELF-SUPPORT")
+    param :service_level, String, :desc => N_("Service level, e.g. SELF-SUPPORT")
     param :lifecycle_environment_id, Integer, :desc => N_("Lifecycle Environment ID"), :required => true
     param :content_view_id, Integer, :desc => N_("Content View ID"), :required => true
     def create
@@ -115,45 +101,6 @@ module Katello
       rhsm_params
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions", N_("Remove subscriptions from a host"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, Integer, :desc => N_("If specified, remove the first instance of a subscription with matching id and quantity"), :required => false
-    end
-    def remove_subscriptions
-      deprecate_entitlement_mode_endpoint
-      #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.with_identifier(subscription['id']))
-        new_hash[subscription['id']].quantities << subscription['quantity']
-        new_hash
-      end
-
-      sync_task(::Actions::Katello::Host::RemoveSubscriptions, @host, pool_id_quantities.values)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
-    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
-    end
-    def add_subscriptions
-      deprecate_entitlement_mode_endpoint
-      if @host.organization.simple_content_access?
-        fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Attaching subscriptions is disabled.")
-      end
-
-      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
-        PoolWithQuantities.new(Pool.with_identifier(sub_params['id']), sub_params['quantity'].to_i)
-      end
-
-      sync_task(::Actions::Katello::Host::AttachSubscriptions, @host, pools_with_quantities)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
     api :GET, "/hosts/:host_id/subscriptions/product_content", N_("Get content and overrides for the host")
     param :host_id, String, :desc => N_("Id of the host"), :required => true
     param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions")
@@ -215,10 +162,6 @@ module Katello
       fail HttpErrors::NotFound, _("Couldn't find specified content view and lifecycle environment.") if @content_view_environment.nil?
     end
 
-    def check_subscriptions
-      fail HttpErrors::BadRequest, _("subscriptions not specified") if params[:subscriptions].blank?
-    end
-
     def check_registration_services
       fail "Unable to register system, not all services available" unless Katello::RegistrationManager.check_registration_services
     end
@@ -228,7 +171,7 @@ module Katello
     end
 
     def action_permission
-      if ['add_subscriptions', 'destroy', 'remove_subscriptions', 'auto_attach', 'content_override'].include?(params[:action])
+      if ['destroy', 'content_override'].include?(params[:action])
         :edit
       elsif ['index', 'events', 'product_content', 'available_release_versions', 'enabled_repositories'].include?(params[:action])
         :view

data/app/controllers/katello/api/v2/hosts_bulk_actions_controller.rb

@@ -1,5 +1,6 @@
 module Katello
   # this is Katello's host bulk actions controller, not to be confused with Foreman's
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include ::Api::V2::BulkHostsExtension
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -13,11 +14,8 @@ module Katello
     before_action :find_deletable_hosts, only: [:destroy_hosts]
     before_action :find_readable_hosts, only: [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, only: [:available_incremental_updates]
-    before_action :find_organization, only: [:add_subscriptions]
     before_action :find_traces, only: [:resolve_traces]
 
-    before_action :validate_organization, only: [:add_subscriptions]
-
     # disable *_count fields on erratum rabl, since they perform N+1 queries
     before_action :disable_erratum_hosts_count
 
@@ -51,8 +49,14 @@ module Katello
           host_collection.save!
 
           final_count = host_collection.host_ids.count - pre_host_collection_count
-          display_messages << _("Successfully added %{count} content host(s) to host collection %{host_collection}.") %
-              {:count => final_count, :host_collection => host_collection.name }
+          msg = if final_count == 0
+                  _("All selected hosts were already members of host collection %{host_collection}.") %
+                              {:host_collection => host_collection.name }
+                else
+                  _("Added %{count} host(s) to host collection %{host_collection}.") %
+                              {:count => final_count, :host_collection => host_collection.name }
+                end
+          display_messages << msg
         end
       end
 
@@ -74,7 +78,7 @@ module Katello
           host_collection.save!
 
           final_count = pre_host_collection_count - host_collection.host_ids.count
-          display_messages << _("Successfully removed %{count} content host(s) from host collection %{host_collection}.") %
+          display_messages << _("Removed %{count} host(s) from host collection %{host_collection}.") %
               {:count => final_count, :host_collection => host_collection.name }
         end
       end
@@ -106,49 +110,6 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, Integer, :desc => N_("Quantity of specified subscription to remove"), :required => false
-    end
-    def remove_subscriptions
-      #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.find(subscription['id']))
-        new_hash[subscription['id']].quantities << subscription['quantity']
-        new_hash
-      end
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::RemoveSubscriptions, @hosts, pool_id_quantities.values)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
-    end
-    def add_subscriptions
-      if @organization.simple_content_access?
-        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
-      end
-
-      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
-        PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
-      end
-
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AttachSubscriptions, @hosts, pools_with_quantities)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts"), deprecated: true
-    param_group :bulk_params
-    def auto_attach
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)
-      respond_for_async :resource => task
-    end
-
     api :PUT, "/hosts/bulk/content_overrides", N_("Set content overrides to one or more hosts")
     param_group :bulk_params
     param :content_overrides, Array, :desc => N_("Array of Content override parameters") do
@@ -310,10 +271,6 @@ module Katello
       find_bulk_hosts(:destroy_hosts, params)
     end
 
-    def validate_organization
-      fail HttpErrors::BadRequest, _("Organization ID is required") if @organization.blank?
-    end
-
     def validate_host_collection_membership_limit
       max_hosts_exceeded = []
       host_ids = @hosts.map(&:id)

data/app/controllers/katello/api/v2/repositories_controller.rb

@@ -676,7 +676,6 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
         root.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
         root.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
         root.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
-        root.content_id = 'INITIAL_DUMMY_VALUE' unless Setting['deb_enable_structured_apt']
       end
 
       if root.ansible_collection?

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

@@ -24,6 +24,9 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
+              # Raise validation error early if invalid
+              @taxonomy.validate!
+
               ::Katello::OrganizationCreator.new(@taxonomy).create!
               @taxonomy.reload
               switch_taxonomy

data/app/lib/actions/candlepin/activation_key/create.rb

@@ -3,7 +3,6 @@ module Actions
     class ActivationKey::Create < Candlepin::Abstract
       input_format do
         param :organization_label
-        param :auto_attach
         param :service_level
         param :release_version
         param :purpose_role
@@ -13,7 +12,6 @@ module Actions
       def run
         output[:response] = ::Katello::Resources::Candlepin::ActivationKey.create(::Katello::Util::Model.uuid,
                                                                                   input[:organization_label],
-                                                                                  input[:auto_attach],
                                                                                   input[:service_level],
                                                                                   input[:release_version],
                                                                                   input[:purpose_role],

data/app/lib/actions/candlepin/activation_key/update.rb

@@ -6,7 +6,6 @@ module Actions
           param :cp_id
           param :release_version
           param :service_level
-          param :auto_attach
           param :purpose_role
           param :purpose_usage
         end
@@ -16,7 +15,6 @@ module Actions
                                                                 input[:cp_id],
                                                                 input[:release_version],
                                                                 input[:service_level],
-                                                                input[:auto_attach],
                                                                 input[:purpose_role],
                                                                 input[:purpose_usage])
         end

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

@@ -16,12 +16,10 @@ module Actions
         def run
           content_url = input[:content_url]
           if input[:type] == ::Katello::Repository::DEB_TYPE
-            # We must retrieve the repository in the run phase, so the latest Pulp version_href is
-            # already set. This is needed to retrieve the latest repository.deb_content_url_options!
+            # We must retrieve the deb? repository in the run phase, so the latest Pulp version_href
+            # is set. This is needed to retrieve the latest repository.deb_content_url_options!
             repository = ::Katello::Repository.find(input[:repository_id])
-            if repository.deb_using_structured_apt?
-              content_url += repository.deb_content_url_options
-            end
+            content_url += repository.deb_content_url_options
           end
 
           output[:response] = ::Katello::Resources::Candlepin::Content.

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

@@ -16,11 +16,10 @@ module Actions
         end
 
         def finalize
+          # finalize, because Katello::Product::ContentCreate updates repository.content_id during finalize!
           content_url = input[:content_url]
-          # We must retrieve the repository in the finalize phase, because Katello::Product::ContentCreate
-          # only updates the repository.content_id in the finalize phase!
           repository = ::Katello::Repository.find(input[:repository_id])
-          if repository.deb_using_structured_apt?
+          if repository.deb?
             content_url += repository.deb_content_url_options
           end
 

data/app/lib/actions/helpers/rolling_cv_repos.rb

@@ -2,7 +2,7 @@ module Actions
   module Helpers
     module RollingCVRepos
       def find_related_rolling_repos(repo)
-        repo.root.repositories.in_environment(repo.environment).where(
+        repo.root.repositories.where(
           content_view_version: ::Katello::ContentViewVersion.where(content_view: ::Katello::ContentView.rolling)
         )
       end

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

@@ -6,7 +6,6 @@ module Actions
           activation_key.save!
           cp_create = plan_action(Candlepin::ActivationKey::Create,
                                   organization_label: activation_key.organization.label,
-                                  auto_attach: activation_key.auto_attach,
                                   service_level: params[:service_level],
                                   release_version: activation_key.release_version,
                                   purpose_role: activation_key.purpose_role,

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

@@ -12,14 +12,12 @@ module Actions
                         cp_id: activation_key.cp_id,
                         release_version: activation_key.release_version,
                         service_level: activation_key.service_level,
-                        auto_attach: activation_key.auto_attach,
                         purpose_role: activation_key.purpose_role,
                         purpose_usage: activation_key.purpose_usage)
           end
         end
 
         def update_candlepin?(activation_key, activation_key_params)
-          cp_changed?(activation_key.auto_attach, activation_key_params[:auto_attach]) ||
           cp_changed?(activation_key.service_level, activation_key_params[:service_level]) ||
           cp_changed?(activation_key.release_version, activation_key_params[:release_version]) ||
           cp_changed?(activation_key.purpose_role, activation_key_params[:purpose_role]) ||

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
-        include Helpers::RollingCVRepos
         # rubocop:disable Metrics/MethodLength
         execution_plan_hooks.use :update_content_counts, :on => :success
         def plan(smart_proxy, options = {})
@@ -59,11 +58,7 @@ module Actions
           smart_proxy_helper.lifecycle_environment_check(environment, repository)
           if repository
             if skip_metatadata_check || !repository.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy).any? { |sph| !sph.finished_at.nil? }
-              if repository.library_instance?
-                [repository] + find_related_rolling_repos(repository)
-              else
-                [repository]
-              end
+              [repository]
             end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count

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

@@ -6,7 +6,7 @@ module Actions
           action_subject gpg_key
           gpg_key.update!(gpg_key_params)
           gpg_key.repositories.each do |repository|
-            if repository.content_type == ::Katello::Repository::DEB_TYPE
+            if repository.deb?
               plan_action(::Actions::Katello::Repository::RefreshRepository, repository)
             end
           end

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

@@ -2,36 +2,30 @@ module Actions
   module Katello
     module ContentView
       class AddRollingRepoClone < Actions::EntryAction
-        include Helpers::SmartProxySyncHelper
-
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
           clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              sequence do
-                clone = content_view.get_repo_clone(library, repository).first
-                if clone.nil?
-                  clone = repository.build_clone(content_view: content_view, environment: library)
-                  clone.save!
-                end
-                plan_action(RefreshRollingRepo, clone, false)
+          environments.each do |environment|
+            concurrence do
+              repositories.each do |repository|
+                sequence do
+                  clone = content_view.get_repo_clone(environment, repository).first
+                  if clone.nil?
+                    clone = repository.build_clone(content_view: content_view, environment: environment)
+                    clone.save!
+                  end
+                  plan_action(RefreshRollingRepo, clone, false)
 
-                view_env_cp_id = content_view.content_view_environment(library).cp_id
-                content_id = repository.content_id
-                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
-                clone_ids << clone.id
+                  view_env_cp_id = content_view.content_view_environment(environment).cp_id
+                  content_id = repository.content_id
+                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
+                  clone_ids << clone.id
+                end
               end
             end
           end
-          plan_self(repository_ids: clone_ids)
-        end
-
-        def run
-          ::Katello::Repository.where(id: input[:repository_ids]).each do |repository|
-            schedule_async_repository_proxy_sync(repository)
-          end
         end
       end
     end

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

@@ -2,20 +2,25 @@ module Actions
   module Katello
     module ContentView
       class Create < Actions::Base
-        def plan(content_view)
+        def plan(content_view, environment_ids = [])
           content_view.save!
           if content_view.rolling?
-            plan_action(AddToEnvironment, content_view.create_new_version, content_view.organization.library)
+            new_version = content_view.create_new_version
+            if environment_ids&.any?
+              ::Katello::KTEnvironment.where(id: environment_ids).each do |environment|
+                plan_action(AddToEnvironment, new_version, environment)
+              end
+            end
             repository_ids = content_view.repository_ids
             if repository_ids.any?
               content_view.reload
-              plan_action(AddRollingRepoClone, content_view, repository_ids)
+              plan_action(AddRollingRepoClone, content_view, repository_ids, environment_ids)
             end
           end
         end
 
         def humanized_name
-          _("Create")
+          _("Create content view")
         end
       end
     end

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

@@ -59,13 +59,6 @@ module Actions
             if options[:importing]
               handle_importing_content(version, options[:path], options[:metadata])
             elsif options[:syncable]
-              if separated_repo_map[:pulp3_deb_multicopy].keys.flatten.present?
-                plan_action(::Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_deb_multicopy], version)
-              end
-              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
-                plan_action(::Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
-              end
-
               # Create import history for syncable imports so they display under hammer's content-import list command.
               if options[:path] && options[:metadata]
                 plan_action(
@@ -76,6 +69,13 @@ module Actions
                   content_view_name: version.content_view.name
                 )
               end
+            else
+              if separated_repo_map[:pulp3_deb_multicopy].keys.flatten.present?
+                plan_action(::Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_deb_multicopy], version)
+              end
+              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+                plan_action(::Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
+              end
             end
 
             concurrence do

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

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module ContentView
       class RefreshRollingRepo < Actions::EntryAction
+        include Helpers::SmartProxySyncHelper
+
         def plan(repository, contents_changed)
           action_subject repository
           sequence do
@@ -23,8 +25,10 @@ module Actions
           repository.last_contents_changed = DateTime.now if repository.version_href != library_instance.version_href
 
           repository.version_href = library_instance.version_href
+          repository.version_prn = library_instance.version_prn
           repository.publication_href = library_instance.publication_href
-          if repository.deb_using_structured_apt?
+          repository.publication_prn = library_instance.publication_prn
+          if repository.deb?
             repository.content_id = library_instance.content_id
           end
           repository.save!
@@ -33,6 +37,7 @@ module Actions
         def finalize
           repository = ::Katello::Repository.find(input[:repository_id])
           repository.clear_smart_proxy_sync_histories if input[:contents_changed]
+          schedule_async_repository_proxy_sync(repository)
         end
       end
     end

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

@@ -2,21 +2,26 @@ module Actions
   module Katello
     module ContentView
       class RemoveRollingRepoClone < Actions::EntryAction
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
+          clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          clone_repo_ids = []
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              clone_repo = content_view.get_repo_clone(library, repository).first
-              next if clone_repo.nil?
+          sequence do
+            environments.each do |environment|
+              concurrence do
+                repositories.each do |repository|
+                  clone_repo = content_view.get_repo_clone(environment, repository).first
+                  next if clone_repo.nil?
 
-              clone_repo_ids << clone_repo.id
-              plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                  clone_ids << clone_repo.id
+                  plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                end
+                plan_action(Candlepin::Environment::SetContent, content_view, environment, content_view.content_view_environment(environment))
+              end
             end
-            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
+            plan_self(repository_ids: clone_ids)
           end
-          plan_self(repository_ids: clone_repo_ids)
         end
 
         def run

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

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module ContentView
       class Update < Actions::EntryAction
-        def plan(content_view, content_view_params)
+        def plan(content_view, content_view_params, environment_ids)
           action_subject content_view
           content_view_params = content_view_params.with_indifferent_access
 
@@ -28,15 +28,42 @@ module Actions
             end
           end
 
-          if content_view.rolling? && content_view_params.key?(:repository_ids)
-            repo_ids_to_add = content_view_params[:repository_ids] - content_view.repository_ids
-            repo_ids_to_remove = content_view.repository_ids - content_view_params[:repository_ids]
+          handle_rolling_content_view(content_view, content_view_params[:repository_ids], environment_ids)
+          content_view.update!(content_view_params)
+        end
 
-            plan_action(AddRollingRepoClone, content_view, repo_ids_to_add) if repo_ids_to_add.any?
-            plan_action(RemoveRollingRepoClone, content_view, repo_ids_to_remove) if repo_ids_to_remove.any?
+        def handle_rolling_content_view(content_view, target_repo_ids, target_env_ids)
+          return unless content_view.rolling?
+
+          add_repo_ids, remove_repo_ids, retain_repo_ids = translate_id_lists(content_view.repository_ids, target_repo_ids)
+
+          if target_env_ids.nil?
+            target_env_ids = retain_env_ids = content_view.environment_ids
+          else
+            add_env_ids, remove_env_ids, retain_env_ids = translate_id_lists(content_view.environment_ids, target_env_ids)
+            ::Katello::KTEnvironment.where(id: add_env_ids).each do |environment|
+              plan_action(AddToEnvironment, content_view.versions[0], environment)
+            end
+            plan_action(AddRollingRepoClone, content_view, retain_repo_ids, add_env_ids) if retain_repo_ids.any? && add_env_ids.any?
+            ::Katello::KTEnvironment.where(id: remove_env_ids).each do |environment|
+              plan_action(RemoveFromEnvironment, content_view, environment)
+            end
           end
 
-          content_view.update!(content_view_params)
+          plan_action(AddRollingRepoClone, content_view, add_repo_ids, target_env_ids) if add_repo_ids.any?
+          plan_action(RemoveRollingRepoClone, content_view, remove_repo_ids, retain_env_ids) if remove_repo_ids.any?
+        end
+
+        def translate_id_lists(current_ids, target_ids)
+          if target_ids.nil?
+            add_ids = remove_ids = []
+            retain_ids = current_ids
+          else
+            add_ids = target_ids - current_ids
+            remove_ids = current_ids - target_ids
+            retain_ids = current_ids - remove_ids
+          end
+          return add_ids, remove_ids, retain_ids
         end
       end
     end

data/app/lib/actions/katello/product/content_create.rb

@@ -7,7 +7,7 @@ module Actions
         def plan(repository)
           root = repository.root
           sequence do
-            if repository.content_id.nil? || repository.content_id == 'INITIAL_DUMMY_VALUE'
+            if repository.content_id.nil?
               content_create = plan_action(Candlepin::Product::ContentCreate,
                                            repository_id: repository.id,
                                            owner:         root.organization.label,
@@ -45,7 +45,7 @@ module Actions
         def finalize
           root = ::Katello::RootRepository.find(input[:root_repository_id])
           content_url = root.custom_content_path
-          if root.deb_using_structured_apt?
+          if root.deb?
             repository = ::Katello::Repository.find(input[:repository_id])
             content_url += repository.deb_content_url_options
             repository.update(:content_id => input[:content_id])

data/app/lib/actions/katello/product/content_destroy.rb

@@ -15,7 +15,7 @@ module Actions
             ::Katello::ProductContent.where(product_id: root_repository.product_id,
                                             content_id: katello_content_id).destroy_all
 
-            if root_repository.repositories.count <= 1 || repository.deb_using_structured_apt?
+            if root_repository.repositories.count <= 1 || repository.deb?
               plan_action(Candlepin::Product::ContentDestroy,
                           owner: root_repository.product.organization.label,
                           content_id: repository.content_id)