katello 3.0.0.rc1 → 3.0.0.rc2

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

@@ -10,7 +10,8 @@ module Actions
         def plan(repository, options = {})
           planned_destroy = options.fetch(:planned_destroy, false)
 
-          skip_environment_update = options.fetch(:organization_destroy, false)
+          skip_environment_update = options.fetch(:skip_environment_update, false) ||
+              options.fetch(:organization_destroy, false)
           action_subject(repository)
 
           if !planned_destroy && !repository.assert_deletable

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

@@ -0,0 +1,23 @@
+module Actions
+  module Katello
+    module Repository
+      class ImportApplicability < Actions::Base
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
+
+        input_format do
+          param :repo_id
+          param :contents_changed
+        end
+
+        def run
+          repo = ::Katello::Repository.find(input[:repo_id])
+          repo.import_host_applicability
+        end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -45,6 +45,7 @@ module Actions
               plan_self(:id => repo.id, :sync_result => output, :user_id => ::User.current.id, :contents_changed => contents_changed)
               plan_action(Pulp::Repository::RegenerateApplicability, :pulp_id => repo.pulp_id, :contents_changed => contents_changed)
             end
+            plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed)
           end
         end
 
@@ -70,14 +71,6 @@ module Actions
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end
-
-        def finalize
-          ::User.current = ::User.anonymous_admin
-          repo = ::Katello::Repository.find(input[:id])
-          repo.import_system_applicability
-        ensure
-          ::User.current = nil
-        end
       end
     end
   end

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

@@ -97,6 +97,14 @@ module Actions
         end
       end
 
+      def rescue_external_task(error)
+        if error.is_a?(::Katello::Errors::PulpError)
+          fail error
+        else
+          super
+        end
+      end
+
       private
 
       def external_task=(external_task_data)

data/app/lib/actions/pulp/consumer/content_install.rb

@@ -20,6 +20,20 @@ module Actions
           task
         end
 
+        def finalize
+          check_error_details
+        end
+
+        def check_error_details
+          output[:pulp_tasks].each do |pulp_task|
+            error_details = pulp_task.try(:[], "result").try(:[], "details").try(:[], "rpm").try(:[], "details").try(:[], "trace")
+            error_message = pulp_task.try(:[], "result").try(:[], "details").try(:[], "rpm").try(:[], "details").try(:[], "message")
+            if error_details.include?("YumDownloadError") && error_message
+              fail _("An error occurred during the sync \n%{error_message}") % {:error_message => error_details}
+            end
+          end
+        end
+
         def presenter
           Consumer::ContentPresenter.new(self)
         end

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

@@ -91,7 +91,8 @@ module Actions
         def distributors
           case input[:content_type]
           when ::Katello::Repository::YUM_TYPE
-            distributors = [yum_distributor, yum_clone_distributor, export_distributor]
+            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

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

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp
+    module Repository
+      class DeleteDistributor < Pulp::Abstract
+        input_format do
+          param :repo_id
+          param :distributor_id
+          param :capsule_id
+        end
+
+        def run
+          output[:response] = pulp_resources.repository.
+            delete_distributor(*input.values_at(:repo_id, :distributor_id))
+        end
+      end
+    end
+  end
+end

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

@@ -7,12 +7,14 @@ module Actions
         end
 
         def plan(repository, input = {})
-          update_or_associate_importer(input[:capsule_id], repository)
-          update_or_associate_distributors(input[:capsule_id], repository)
+          repository_details = pulp_extensions(input[:capsule_id]).repository.retrieve_with_details(repository.pulp_id)
+          update_or_associate_importer(input[:capsule_id], repository, repository_details)
+          update_or_associate_distributors(input[:capsule_id], repository, repository_details)
+          remove_unnecessary_distributors(input[:capsule_id], repository, repository_details)
         end
 
-        def update_or_associate_importer(capsule_id, repository)
-          existing_importers = pulp_extensions(capsule_id).repository.retrieve_with_details(repository.pulp_id)["importers"]
+        def update_or_associate_importer(capsule_id, repository, repository_details)
+          existing_importers = repository_details["importers"]
           importer = capsule_id ? repository.generate_importer(true) : repository.generate_importer
           importer_config = capsule_id ? importer.config.merge!(importer_certs(repository)) : importer.config
           found = existing_importers.find { |i| i['importer_type_id'] == importer.id }
@@ -35,10 +37,10 @@ module Actions
           end
         end
 
-        def update_or_associate_distributors(capsule_id, repository)
+        def update_or_associate_distributors(capsule_id, repository, repository_details)
           concurrence do
-            existing_distributors = pulp_extensions(capsule_id).repository.retrieve_with_details(repository.pulp_id)["distributors"]
-            repository.generate_distributors.each do |distributor|
+            existing_distributors = repository_details["distributors"]
+            repository.generate_distributors(capsule_id.present?).each do |distributor|
               found = existing_distributors.find { |i| i['distributor_type_id'] == distributor.type_id }
               if found
                 plan_action(::Actions::Pulp::Repository::RefreshDistributor,
@@ -60,6 +62,22 @@ module Actions
           end
         end
 
+        def remove_unnecessary_distributors(capsule_id, repository, repository_details)
+          concurrence do
+            existing_distributors = repository_details["distributors"]
+            generated_distributors = repository.generate_distributors(capsule_id.present?)
+            existing_distributors.each do |distributor|
+              found = generated_distributors.find { |dist| dist.type_id == distributor['distributor_type_id'] }
+              unless found
+                plan_action(Pulp::Repository::DeleteDistributor, :repo_id => repository.pulp_id,
+                                                                 :distributor_id => distributor['id'],
+                                                                 :capsule_id => capsule_id
+                           )
+              end
+            end
+          end
+        end
+
         def importer_certs(repository)
           ueber_cert = ::Cert::Certs.ueber_cert(repository.organization)
 

data/app/lib/katello/api/v2/error_handling.rb

@@ -19,7 +19,7 @@ module Katello
           rescue_from Errors::SecurityViolation, :with => :rescue_from_security_violation
           rescue_from Errors::ConflictException, :with => :rescue_from_conflict_exception
           rescue_from Errors::UnsupportedActionException, :with => :rescue_from_unsupported_action_exception
-          rescue_from Errors::MaxContentHostsReachedException, :with => :rescue_from_max_content_hosts_reached_exception
+          rescue_from Errors::MaxHostsReachedException, :with => :rescue_from_max_hosts_reached_exception
           rescue_from Errors::CdnSubstitutionError, :with => :rescue_from_bad_data
           rescue_from ActionController::ParameterMissing, :with => :rescue_from_missing_param
         end
@@ -79,7 +79,7 @@ module Katello
           respond_for_exception(exception, :status => :unprocessable_entity)
         end
 
-        def rescue_from_max_content_hosts_reached_exception(exception)
+        def rescue_from_max_hosts_reached_exception(exception)
           respond_for_exception(exception, :status => :conflict, :with_logging => false)
         end
 

data/app/lib/katello/capsule_content.rb

@@ -105,6 +105,11 @@ module Katello
       @capsule.default_capsule?
     end
 
+    def orphaned_repos
+      @capsule.pulp_repositories.map { |x| x["id"] } - current_repositories.map { |x| x.pulp_id }
+    end
+
+    # shows repos available both in katello and on the capsule.
     def current_repositories(environment_id = nil, content_view_id = nil)
       @current_repositories ||= @capsule.pulp_repositories
       katello_repo_ids = []
@@ -140,6 +145,12 @@ module Katello
       self.capsule.url + "/pulp/api/v2/"
     end
 
+    def pulp_repo_facts(pulp_id)
+      self.pulp_server.extensions.repository.retrieve_with_details(pulp_id)
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
     def self.with_environment(environment, include_default = false)
       features = [SmartProxy::PULP_NODE_FEATURE]
       features << SmartProxy::PULP_FEATURE if include_default

data/app/lib/katello/errors.rb

@@ -37,7 +37,7 @@ module Katello
 
     class ConnectionRefusedException < StandardError; end
 
-    class MaxContentHostsReachedException < StandardError; end
+    class MaxHostsReachedException < StandardError; end
 
     class OrganizationDestroyException < StandardError; end
 

data/app/mailers/katello/errata_mailer.rb

@@ -9,7 +9,7 @@ module Katello
       end
 
       set_locale_for(user) do
-        mail(:to => user.mail, :subject => _("Katello Host Advisory"))
+        mail(:to => user.mail, :subject => _("Host Errata Advisory"))
       end
     end
 
@@ -22,7 +22,7 @@ module Katello
       @errata = all_errata.take(100).group_by(&:errata_type)
 
       set_locale_for(user) do
-        mail(:to => user.mail, :subject => (_("Katello Sync Summary for %s") % @repo.name))
+        mail(:to => user.mail, :subject => (_("Sync Summary for %s") % @repo.name))
       end
     end
 
@@ -37,7 +37,7 @@ module Katello
       @errata = @content_facets.map(&:installable_errata).flatten.uniq
 
       set_locale_for(user) do
-        mail(:to => user.mail, :subject => (_("Katello Promotion Summary for %{content_view}") % {:content_view => @content_view.name}))
+        mail(:to => user.mail, :subject => (_("Promotion Summary for %{content_view}") % {:content_view => @content_view.name}))
       end
     end
 

data/app/models/katello/activation_key.rb

@@ -30,11 +30,11 @@ module Katello
     validates :name, :presence => true
     validates :name, :uniqueness => {:scope => :organization_id}
     validate :environment_exists
-    validates :max_content_hosts, :numericality => {:less_than => 2**31, :allow_nil => true}
-    validates_each :max_content_hosts do |record, attr, value|
-      if record.unlimited_content_hosts
+    validates :max_hosts, :numericality => {:less_than => 2**31, :allow_nil => true}
+    validates_each :max_hosts do |record, attr, value|
+      if record.unlimited_hosts
         unless value.nil?
-          record.errors[attr] << _("cannot be set because unlimited content hosts is set")
+          record.errors[attr] << _("cannot be set because unlimited hosts is set")
         end
       else
         if value.nil?
@@ -107,7 +107,7 @@ module Katello
     end
 
     def available_content
-      self.products.map(&:available_content).flatten.uniq { |product| product.content.id }
+      self.products ? self.products.map(&:available_content).flatten.uniq { |product| product.content.id } : []
     end
 
     def valid_content_label?(content_label)
@@ -178,7 +178,7 @@ module Katello
     def copy(new_name)
       new_key = ActivationKey.new
       new_key.name = new_name
-      new_key.attributes = self.attributes.slice("description", "environment_id", "organization_id", "content_view_id", "max_content_hosts", "unlimited_content_hosts")
+      new_key.attributes = self.attributes.slice("description", "environment_id", "organization_id", "content_view_id", "max_hosts", "unlimited_hosts")
       new_key.host_collection_ids = self.host_collection_ids
       new_key
     end

data/app/models/katello/candlepin/product_content.rb

@@ -34,5 +34,20 @@ module Katello
       override = activation_key.content_overrides.find { |pc| pc[:contentLabel] == content.label }
       override.nil? ? 'default' : override[:value]
     end
+
+    def content_type
+      self.content.type
+    end
+
+    def displayable?
+      case content_type
+      when ::Katello::Repository::CANDLEPIN_DOCKER_TYPE
+        false
+      when ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
+        ::Katello::RepositoryTypeManager.enabled?(Repository::OSTREE_TYPE)
+      else
+        true
+      end
+    end
   end
 end

data/app/models/katello/concerns/content_facet_host_extensions.rb

@@ -23,8 +23,11 @@ module Katello
         has_many :applicable_errata, :through => :content_facet
 
         scoped_search :in => :content_view, :on => :name, :complete_value => true, :rename => :content_view
+        scoped_search :in => :content_facet, :on => :content_view_id, :rename => :content_view_id
         scoped_search :in => :lifecycle_environment, :on => :name, :complete_value => true, :rename => :lifecycle_environment
+        scoped_search :in => :content_facet, :on => :lifecycle_environment_id, :rename => :lifecycle_environment_id
         scoped_search :in => :applicable_errata, :on => :errata_id, :rename => :applicable_errata, :complete_value => true, :ext_method => :find_by_applicable_errata
+        scoped_search :in => :applicable_errata, :on => :errata_id, :rename => :installable_errata, :complete_value => true, :ext_method => :find_by_installable_errata
 
         accepts_nested_attributes_for :content_facet, :reject_if => proc { |attributes| attributes['content_view_id'].blank? && attributes['lifecycle_environment_id'].blank? }
         attr_accessible :content_facet_attributes
@@ -40,6 +43,16 @@ module Katello
             { :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.pluck(:id).join(',')})" }
           end
         end
+
+        def find_by_installable_errata(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::Erratum.table_name}.errata_id #{operator} ?", value_to_sql(operator, value)])
+          facets = Katello::Host::ContentFacet.joins_installable_errata.where(conditions)
+          if facets.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{facets.pluck(:host_id).join(',')})" }
+          end
+        end
       end
     end
   end

data/app/models/katello/concerns/operatingsystem_extensions.rb

@@ -3,15 +3,25 @@ module Katello
     module OperatingsystemExtensions
       extend ActiveSupport::Concern
 
+      REDHAT_ATOMIC_HOST_DISTRO_NAME = "Red Hat Enterprise Linux Atomic Host"
+      REDHAT_ATOMIC_HOST_OS = "RedHat_Enterprise_Linux_Atomic_Host"
+
       included do
         after_create :assign_templates!
+        before_create :set_atomic_attributes, :if => proc { |os| os.name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS }
       end
 
       def assign_templates!
         # Automatically assign default templates
         if self.family == 'Redhat'
           TemplateKind.all.each do |kind|
-            if (template = ProvisioningTemplate.find_by_name(Setting["katello_default_#{kind.name}"]))
+            if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && kind.name == "provision"
+              provisioning_template_name = Setting["katello_default_atomic_provision"]
+            else
+              provisioning_template_name = Setting["katello_default_#{kind.name}"]
+            end
+
+            if (template = ProvisioningTemplate.find_by_name(provisioning_template_name))
               provisioning_templates << template unless provisioning_templates.include?(template)
               if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
                 OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
@@ -24,6 +34,12 @@ module Katello
           end
         end
       end
+
+      def set_atomic_attributes
+        self.description = "#{::Operatingsystem::REDHAT_ATOMIC_HOST_DISTRO_NAME} #{release}"
+        self.architectures << Architecture.where(:name => "x86_64").first_or_create
+        self.family = "Redhat"
+      end
     end
   end
 end

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -51,7 +51,9 @@ module Katello
         table_name = self.repository_association_class.table_name
         attribute_name = "#{self.name.demodulize.underscore}_id"
 
-        existing_ids = self.repository_association_class.where(:repository_id => repository).pluck(attribute_name)
+        existing_ids = self.repository_association_class.uncached do
+          self.repository_association_class.where(:repository_id => repository).pluck(attribute_name)
+        end
         new_ids = associated_ids - existing_ids
         delete_ids = existing_ids - associated_ids
 

data/app/models/katello/concerns/setting_extensions.rb

@@ -0,0 +1,12 @@
+module Katello
+  module Concerns
+    module SettingExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        validates :value, inclusion: { in: ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES },
+          if: ->(setting) { setting.name == 'default_download_policy' }
+      end
+    end
+  end
+end

data/app/models/katello/content_view.rb

@@ -25,7 +25,7 @@ module Katello
       end
     end
 
-    has_many :content_view_repositories, :dependent => :destroy
+    has_many :content_view_repositories, :dependent => :destroy, :inverse_of => :content_view
     has_many :repositories, :through => :content_view_repositories, :class_name => "Katello::Repository",
                             :after_remove => :remove_repository
 
@@ -83,9 +83,9 @@ module Katello
       new_view = ContentView.new
       new_view.name = new_name
       new_view.attributes = self.attributes.slice("description", "organization_id", "default", "composite")
+      new_view.save!
       new_view.repositories = self.repositories
       new_view.components = self.components
-      new_view.save!
 
       self.content_view_puppet_modules.each do |puppet_module|
         new_view.content_view_puppet_modules << puppet_module.dup

data/app/models/katello/erratum.rb

@@ -54,6 +54,13 @@ module Katello
       return self.errata_id <=> other.errata_id
     end
 
+    def self.with_identifiers(ids)
+      ids = [ids] unless ids.is_a?(Array)
+      ids.map!(&:to_s)
+      id_integers = ids.map { |string| Integer(string) rescue -1 }
+      where("#{self.table_name}.id = (?) or #{self.table_name}.uuid = (?) or #{self.table_name}.errata_id = (?)", id_integers, ids, ids)
+    end
+
     def hosts_applicable
       self.content_facets_applicable.joins(:host)
     end