katello 3.1.0.1 → 3.2.0.rc1

data/app/helpers/katello/concerns/hosts_and_hostgroups_helper_extensions.rb

@@ -0,0 +1,19 @@
+module Katello
+  module Concerns
+    module HostsAndHostgroupsHelperExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :puppet_environment_field, :katello
+      end
+
+      def puppet_environment_field_with_katello(form, environments_choice, select_options = {}, html_options = {})
+        html_options.merge!(
+          :label => _("Puppet Environment"),
+          'data-content_puppet_match' => (@host || @hostgroup).new_record? || (@host || @hostgroup).content_and_puppet_match?,
+          :help_inline => link_to(_("Reset Puppet Environment to match selected Content View"), '#', :id => 'reset_puppet_environment'))
+        puppet_environment_field_without_katello(form, environments_choice, select_options, html_options)
+      end
+    end
+  end
+end

data/app/lib/actions/candlepin/import_pool_handler.rb

@@ -69,12 +69,17 @@ module Actions
       def reindex_consumer(message)
         if message.content['newEntity']
           uuid = JSON.parse(message.content['newEntity'])['consumer']['uuid']
-          subscription_facet = ::Katello::Host::SubscriptionFacet.find_by_uuid(uuid)
-          if subscription_facet.nil?
-            @logger.debug "skip re-indexing of non-existent registered host #{uuid}"
-          else
-            @logger.debug "re-indexing content host #{subscription_facet.host.name}"
-            subscription_facet.update_subscription_status
+          skip_msg = "skip re-indexing of non-existent content host #{uuid}"
+          begin
+            subscription_facet = ::Katello::Host::SubscriptionFacet.find_by_uuid(uuid)
+            if subscription_facet.nil?
+              @logger.debug "skip re-indexing of non-existent registered host #{uuid}"
+            else
+              @logger.debug "re-indexing content host #{subscription_facet.host.name}"
+              subscription_facet.update_subscription_status
+            end
+          rescue RestClient::ResourceNotFound, RestClient::Gone
+            @logger.debug(skip_msg)
           end
         end
       end

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

@@ -17,7 +17,7 @@ module Actions
 
         def create_repo_in_pulp(capsule_content, repository)
           ueber_cert = ::Cert::Certs.ueber_cert(repository.organization)
-          relative_path = repository_relative_path(repository)
+          relative_path = repository_relative_path(repository, capsule_content)
           checksum_type = repository.yum? ? repository.checksum_type : nil
 
           plan_action(Pulp::Repository::Create,
@@ -37,9 +37,9 @@ module Actions
                       capsule_id: capsule_content.capsule.id)
         end
 
-        def repository_relative_path(repository)
+        def repository_relative_path(repository, capsule_content)
           if repository.is_a? ::Katello::ContentViewPuppetEnvironment
-            repository.generate_puppet_path
+            repository.generate_puppet_path(capsule_content.capsule)
           elsif repository.puppet? && (repository.is_a? ::Katello::Repository)
             nil
           else

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

@@ -27,17 +27,31 @@ module Actions
               need_updates.each do |repo|
                 plan_action(Pulp::Repository::Refresh, repo, capsule_id: capsule_content.capsule.id)
               end
-
               plan_action(ConfigureCapsule, capsule_content, environment, content_view)
+              sync_repos_to_capsule(capsule_content, repository_ids)
+              plan_action(RemoveOrphans, :capsule_id => capsule_content.capsule.id)
+            end
+          end
+        end
 
-              concurrence do
-                repository_ids.each do |repo_id|
-                  plan_action(Pulp::Consumer::SyncCapsule,
+        def sync_repos_to_capsule(capsule_content, repository_ids)
+          concurrence do
+            repository_ids.each do |repo_id|
+              sequence do
+                repo = ::Katello::Repository.where(:pulp_id => repo_id).first ||
+                       ::Katello::ContentViewPuppetEnvironment.where(:pulp_id => repo_id).first
+                if repo && repo.content_type != "yum"
+                  # we unassociate units in non-yum repos in order to avoid version conflicts
+                  # during publish. (i.e. two versions of a puppet module in the same repo)
+                  plan_action(Pulp::Consumer::UnassociateUnits,
                               capsule_id: capsule_content.capsule.id,
                               repo_pulp_id: repo_id)
                 end
+
+                plan_action(Pulp::Consumer::SyncCapsule,
+                            capsule_id: capsule_content.capsule.id,
+                            repo_pulp_id: repo_id)
               end
-              plan_action(RemoveOrphans, :capsule_id => capsule_content.capsule.id)
             end
           end
         end
@@ -65,13 +79,13 @@ module Actions
           (need_distributor_update + need_importer_update).uniq
         end
 
-        def repos_needing_distributor_updates(capsule, environment, content_view)
-          repos = capsule.repos_available_to_capsule(environment, content_view)
+        def repos_needing_distributor_updates(capsule_content, environment, content_view)
+          repos = capsule_content.repos_available_to_capsule(environment, content_view)
           repos.select do |repo|
-            repo_details = capsule.pulp_repo_facts(repo.pulp_id)
+            repo_details = capsule_content.pulp_repo_facts(repo.pulp_id)
             next unless repo_details
             capsule_distributors = repo_details["distributors"]
-            !repo.distributors_match?(capsule_distributors)
+            !repo.distributors_match?(capsule_distributors, capsule_content.capsule)
           end
         end
 

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

@@ -4,7 +4,7 @@ module Actions
       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)
+          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)

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

@@ -11,10 +11,10 @@ module Actions
 
           content_view = ::Katello::ContentView.find(input[:content_view])
           environment = ::Katello::KTEnvironment.find(input[:environment])
-          users = ::User.select { |user| user.receives?(:katello_promote_errata) && user.can?(:view_content_views, content_view) }
+          users = ::User.select { |user| user.receives?(:promote_errata) && user.can?(:view_content_views, content_view) }
 
           begin
-            MailNotification[:katello_promote_errata].deliver_now(:users => users, :content_view => content_view, :environment => environment) unless users.blank?
+            MailNotification[:promote_errata].deliver_now(:users => users, :content_view => content_view, :environment => environment) unless users.blank?
           rescue => e
             message = _('Unable to send errata e-mail notification: %{error}' % {:error => e})
             Rails.logger.error(message)

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

@@ -67,7 +67,66 @@ module Actions
         end
 
         def humanized_name
-          _("Incremental Update")
+          total_count = total_counts(input)
+          _("Incremental Update of %{content_view_count} Content View Version(s) " %
+            {:content_view_count => total_count[:content_view_count]}) + content_output(total_count)
+        end
+
+        def total_counts(input)
+          total_count = {}
+          if input[:version_outputs]
+            content_view_count = input[:version_outputs].length
+            input[:version_outputs].map do |version_output|
+              added_units = version_output.try(:[], :output).try(:[], :added_units)
+              if added_units
+                total_count[:errata_count] = added_units[:erratum].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
+          total_count[:content_view_count] = content_view_count
+          total_count
+        end
+
+        def content_output(total_count)
+          content = content_output_collection(total_count)
+          if content.count >= 1
+            message_output = _("with")
+            if content.count == 1
+              message_output + content[0]
+            else
+              message_output += content.pop
+              while content.count > 0
+                if content.count == 1
+                  message_output = message_output + _(", and") + content.pop
+                else
+                  message_output = message_output + "," + content.pop
+                end
+              end
+            end
+          else
+            message_output = ""
+          end
+          message_output
+        end
+
+        def content_output_collection(total_count)
+          content = []
+          if total_count[:errata_count] && total_count[:errata_count] > 0
+            errata = _(" %{errata_count} Errata" % {:errata_count => total_count[:errata_count]})
+            content << errata
+          end
+          if total_count[:rpm_count] && total_count[:rpm_count] > 0
+            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
 
         def presenter

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

@@ -28,7 +28,7 @@ module Actions
             unless organization_destroy
               concurrence do
                 all_cv_envs.each do |cv_env|
-                  if cv_env.systems.any? || cv_env.activation_keys.any?
+                  if cv_env.hosts.any? || cv_env.activation_keys.any?
                     plan_action(ContentViewEnvironment::ReassignObjects, cv_env, options)
                   end
                 end
@@ -95,7 +95,7 @@ module Actions
           end
           all_cv_envs = combined_cv_envs(cv_envs, versions)
 
-          if all_cv_envs.flat_map(&:systems).any? && system_cve(options).nil?
+          if all_cv_envs.flat_map(&:hosts).any? && system_cve(options).nil?
             fail _("Unable to reassign systems. Please check system_content_view_id and system_environment_id.")
           end
 

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

@@ -20,7 +20,7 @@ module Actions
                 end
               end
 
-              if puppet_env = content_view.puppet_env(environment)
+              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

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

@@ -4,8 +4,8 @@ module Actions
       class ReassignObjects < Actions::Base
         def plan(content_view_environment, options)
           concurrence do
-            content_view_environment.systems.each do |system|
-              plan_action(System::Reassign, system, options[:system_content_view_id], options[:system_environment_id])
+            content_view_environment.hosts.each do |host|
+              plan_action(Host::Reassign, host, options[:system_content_view_id], options[:system_environment_id])
             end
 
             content_view_environment.activation_keys.each do |key|

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

@@ -3,11 +3,13 @@ module Actions
     module ContentViewPuppetEnvironment
       class Create < Actions::EntryAction
         def plan(puppet_environment, clone = false)
+          internal_capsule = SmartProxy.default_capsule
+          fail _("Content View %s  cannot be published without an internal capsule." % puppet_environment.name) unless internal_capsule
           puppet_environment.save!
           action_subject(puppet_environment)
           plan_self
 
-          puppet_path = puppet_environment.generate_puppet_path
+          puppet_path = puppet_environment.generate_puppet_path(internal_capsule)
 
           sequence do
             plan_action(Pulp::Repository::Create,

data/app/lib/actions/katello/host/attach_subscriptions.rb

@@ -4,16 +4,21 @@ module Actions
       class AttachSubscriptions < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
 
-        def plan(host, pools_with_quantities)
+        def plan(host, pools_with_quantities_params)
           action_subject(host)
-
           sequence do
             pool_ids = []
+            pools_with_quantities = pools_with_quantities_params.map do |pool_with_quantity|
+              ::Katello::PoolWithQuantities.fetch(pool_with_quantity)
+            end
+            existing_pool_ids = host.subscription_facet.candlepin_consumer.pool_ids
             pools_with_quantities.each do |pool_with_quantities|
-              pool_ids << pool_with_quantities.pool.id
-              pool_with_quantities.quantities.each do |quantity|
-                plan_action(::Actions::Candlepin::Consumer::AttachSubscription, :uuid => host.subscription_facet.uuid,
-                            :pool_uuid => pool_with_quantities.pool.cp_id, :quantity => quantity)
+              unless existing_pool_ids.include?(pool_with_quantities.pool.cp_id.to_s)
+                pool_ids << pool_with_quantities.pool.id
+                pool_with_quantities.quantities.each do |quantity|
+                  plan_action(::Actions::Candlepin::Consumer::AttachSubscription, :uuid => host.subscription_facet.uuid,
+                              :pool_uuid => pool_with_quantities.pool.cp_id, :quantity => quantity)
+                end
               end
             end
 
@@ -23,6 +28,8 @@ module Actions
 
         def finalize
           ::Katello::Pool.where(:id => input[:pool_ids]).each(&:import_data)
+          host = ::Host.find_by(:id => input[:managed][:id])
+          host.subscription_facet.update_subscription_status
         end
 
         def rescue_strategy

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

@@ -17,11 +17,6 @@ module Actions
             plan_action(Pulp::Consumer::Destroy, uuid: host.content_facet.uuid) if host.content_facet.try(:uuid)
           end
 
-          if host.content_host
-            plan_self(:pool_ids => pool_ids(host))
-            host.content_host.destroy!
-          end
-
           host.subscription_facet.try(:destroy!)
 
           if unregistering
@@ -41,20 +36,6 @@ module Actions
           end
         end
 
-        def pool_ids(host)
-          host.content_host.pools.map { |p| p["id"] }
-        rescue RestClient::Gone
-          Rails.logger.warn("Host #{host.name} (#{host.subscription_facet.uuid}) removed from candlepin.")
-          []
-        end
-
-        def finalize
-          input[:pool_ids].each do |pool_id|
-            pool = ::Katello::Pool.where(:cp_id => pool_id).first
-            pool.import_data if pool
-          end
-        end
-
         def humanized_name
           _("Destroy Content Host")
         end

data/app/lib/actions/katello/host/generate_applicability.rb

@@ -4,17 +4,22 @@ module Actions
       class GenerateApplicability < Actions::Base
         middleware.use Actions::Middleware::KeepCurrentUser
 
-        def plan(hosts)
+        def plan(hosts, use_queue = true)
           uuids = hosts.map { |host| host.content_facet.try(:uuid) }.compact
           unless uuids.empty?
             plan_action(Pulp::Consumer::GenerateApplicability, :uuids => uuids)
-            plan_self(:host_ids => hosts.map(&:id))
+            plan_self(:host_ids => hosts.map(&:id), :use_queue => use_queue)
           end
         end
 
         def finalize
           input[:host_ids].each do |host_id|
-            ::Katello::EventQueue.push_event(::Katello::Events::ImportHostErrata::EVENT_TYPE, host_id)
+            if input[:use_queue]
+              ::Katello::EventQueue.push_event(::Katello::Events::ImportHostErrata::EVENT_TYPE, host_id)
+            else
+              host = ::Host.find(host_id)
+              host.content_facet.try(:import_applicability, true) if host
+            end
           end
         end
       end

data/app/lib/actions/katello/host/hypervisors.rb

@@ -2,19 +2,27 @@ module Actions
   module Katello
     module Host
       class Hypervisors < Actions::EntryAction
-        def plan(environment, content_view, hypervisor_params)
+        def plan(hypervisor_params)
           sequence do
-            hypervisor_results = plan_action(::Actions::Candlepin::Consumer::Hypervisors, hypervisor_params)
-            return if hypervisor_results.error
-
-            plan_action(Katello::Host::HypervisorsUpdate, environment, content_view, hypervisor_results.output[:results])
-
-            plan_self(:results => hypervisor_results.output[:results])
+            hypervisor_results = ::Katello::Resources::Candlepin::Consumer.register_hypervisors(hypervisor_params)
+            plan_action(Katello::Host::HypervisorsUpdate, parse_hypervisors(hypervisor_results))
           end
         end
 
-        def run
-          output[:results] = input[:results]
+        def parse_hypervisors(hypervisor_results)
+          hypervisors = []
+          %w(created updated unchanged).each do |group|
+            if hypervisor_results[group]
+              hypervisors += hypervisor_results[group].map do |hypervisor|
+                {
+                  :name => hypervisor['name'],
+                  :uuid => hypervisor['uuid'],
+                  :organization_label => hypervisor['owner']['key']
+                }
+              end
+            end
+          end
+          hypervisors
         end
       end
     end

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -4,9 +4,8 @@ module Actions
       class HypervisorsUpdate < Actions::EntryAction
         middleware.use ::Actions::Middleware::RemoteAction
 
-        def plan(environment, content_view, hypervisor_results)
-          plan_self(:environment_id => environment.id, :content_view_id => content_view.id,
-                    :hypervisor_results => hypervisor_results)
+        def plan(hypervisors)
+          plan_self(:hypervisors => hypervisors)
         end
 
         def run
@@ -14,64 +13,36 @@ module Actions
         end
 
         def finalize
-          environment = ::Katello::KTEnvironment.find(input[:environment_id])
-          content_view = ::Katello::ContentView.find(input[:content_view_id])
-          hypervisor_results = input[:hypervisor_results]
+          hypervisors = input[:hypervisors]
 
-          %w(created updated unchanged).each do |group|
-            if hypervisor_results[group]
-              hypervisor_results[group].each do |hypervisor|
-                update_or_create_hypervisor(environment, content_view, hypervisor)
-              end
-            end
+          if hypervisors
+            hypervisors.each { |hypervisor| update_or_create_hypervisor(hypervisor) }
           end
         end
 
-        def update_or_create_hypervisor(environment, content_view, hypervisor_json)
-          name = hypervisor_json[:name]
+        def update_or_create_hypervisor(hypervisor_json)
+          organization = ::Organization.find_by(:label => hypervisor_json[:organization_label])
 
           # Since host names must be unique yet hypervisors may have unique subscription
           # facets in different orgs
-          duplicate_name = "virt-who-#{name}-#{content_view.organization.id}"
-          host = find_host_by_uuid_or_name(hypervisor_json)
-          if host
-            fail _("Host '%{name}' does not belong to an organization") % {:name => name} unless host.organization
-            if host.organization.id != content_view.organization.id
-              name = duplicate_name
-              host = nil
-            end
-          else
-            name = duplicate_name
+          sanitized_name = ::Katello::Host::SubscriptionFacet.sanitize_name(hypervisor_json[:name])
+          duplicate_name = "virt-who-#{sanitized_name}-#{organization.id}"
+          host = ::Katello::Host::SubscriptionFacet.find_by(:uuid => hypervisor_json[:uuid]).try(:host)
+          host ||= ::Host.find_by(:name => duplicate_name)
+          if host && host.organization.try(:id) != organization.id
+            fail _("Host '%{name}' does not belong to an organization") % {:name => host.name} unless host.organization
+            host = nil
           end
 
-          host ||= create_host_for_hypervisor(name, content_view.organization)
+          host ||= create_host_for_hypervisor(duplicate_name, organization)
           host.subscription_facet ||= ::Katello::Host::SubscriptionFacet.new
           host.subscription_facet.host_id = host.id
           host.subscription_facet.update_from_consumer_attributes(hypervisor_json)
           host.subscription_facet.uuid = hypervisor_json[:uuid]
           host.subscription_facet.save!
-
-          # TODO: Remove this legacy
-          # http://projects.theforeman.org/issues/12556
-          unless ::Katello::Hypervisor.find_by(:name => name)
-            hypervisor = ::Katello::Hypervisor.new(:environment_id => environment.id,
-                                        :content_view_id => content_view.id)
-            hypervisor.name = name
-            hypervisor.cp_type = 'hypervisor'
-            hypervisor.orchestration_for = :hypervisor
-            hypervisor.load_from_cp(hypervisor_json)
-            hypervisor.save!
-            host.content_host = hypervisor
-          end
-
           host.save!
         end
 
-        def find_host_by_uuid_or_name(hypervisor_json)
-          facet = ::Katello::Host::SubscriptionFacet.find_by(:uuid => hypervisor_json[:uuid])
-          facet.nil? ? ::Host.find_by(:name => hypervisor_json[:name]) : facet.host
-        end
-
         def create_host_for_hypervisor(name, organization, location = nil)
           location ||= Location.default_location
           host = ::Host::Managed.new(:name => name, :organization => organization,
@@ -79,6 +50,10 @@ module Actions
           host.save!
           host
         end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end