katello 4.5.1 → 4.8.0.rc2

data/app/lib/katello/errors.rb

@@ -128,10 +128,11 @@ module Katello
       end
     end
 
+    class UpstreamCandlepinError < CandlepinError; end
     class UpstreamConsumerGone < StandardError
       def message
-        _("The Subscription Allocation providing the imported manifest has been removed. " \
-          "Please create a new Subscription Allocation and import the new manifest.")
+        _("The manifest doesn't exist on console.redhat.com. " \
+          "Please create and import a new manifest.")
       end
     end
 
@@ -154,7 +155,7 @@ module Katello
 
     class NoManifestImported < StandardError
       def message
-        _("Current organization has no manifest imported.")
+        _("Current organization does not have a manifest imported.")
       end
     end
 

data/app/lib/katello/event_daemon/runner.rb

@@ -6,10 +6,6 @@ module Katello
       @cache = ActiveSupport::Cache::MemoryStore.new
 
       class << self
-        def initialize
-          FileUtils.touch(lock_file)
-        end
-
         def settings
           SETTINGS[:katello][:event_daemon]
         end
@@ -24,12 +20,16 @@ module Katello
           pid_dir.join('katello_event_daemon.pid')
         end
 
+        def tmp_dir
+          Rails.root.join('tmp')
+        end
+
         def pid_dir
-          Rails.root.join('tmp', 'pids')
+          tmp_dir.join('pids')
         end
 
         def lock_file
-          Rails.root.join('tmp', 'katello_event_daemon.lock')
+          tmp_dir.join('katello_event_daemon.lock')
         end
 
         def write_pid_file
@@ -49,10 +49,13 @@ module Katello
 
         def start
           return unless runnable?
-          lockfile = File.open(lock_file, 'r')
-          begin
+
+          FileUtils.mkdir_p(tmp_dir)
+          FileUtils.touch(lock_file)
+
+          File.open(lock_file, 'r') do |lockfile|
             lockfile.flock(File::LOCK_EX)
-            return if started? # ensure it wasn't started while we waited for the lock
+            return nil if started? # ensure it wasn't started while we waited for the lock
             start_monitor_thread
             write_pid_file
 

data/app/lib/katello/resources/candlepin/consumer.rb

@@ -34,10 +34,11 @@ module Katello
             consumers
           end
 
-          def create(env_id, parameters, activation_key_cp_ids)
+          def create(env_ids, parameters, activation_key_cp_ids, org)
             parameters['installedProducts'] ||= [] #if installed products is nil, candlepin won't attach custom products
-            url = "/candlepin/environments/#{env_id}/consumers/"
-            url += "?activation_keys=" + activation_key_cp_ids.join(",") if activation_key_cp_ids.length > 0
+            parameters['environments'] = env_ids.map { |cp_id| { id: cp_id } }
+            url = "/candlepin/consumers/?owner=#{org.label}"
+            url += "&activation_keys=" + activation_key_cp_ids.join(",") if activation_key_cp_ids.length > 0
 
             response = self.post(url, parameters.to_json, self.default_headers).body
             JSON.parse(response).with_indifferent_access
@@ -69,6 +70,9 @@ module Katello
             if params.empty?
               true
             else
+              if params.key?(:environment) && params[:environment].key?(:id)
+                params[:environments] = [{"id": params[:environment][:id]}]
+              end
               self.put(path(uuid), params.to_json, self.default_headers).body
             end
             # consumer update doesn't return any data atm
@@ -89,7 +93,7 @@ module Katello
             self.put(path(uuid), {:lastCheckin => checkin_date}.to_json, self.default_headers).body
           end
 
-          def available_pools(owner_label, uuid, listall = false)
+          def available_pools(owner_label, uuid, listall: false)
             url = Resources::Candlepin::Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}&add_future=true"
             response = Candlepin::CandlepinResource.get(url, self.default_headers).body
             JSON.parse(response)
@@ -104,8 +108,7 @@ module Katello
             # Export is a zip file
             headers = self.default_headers
             headers['accept'] = 'application/zip'
-            response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'export'), headers)
-            response
+            Candlepin::CandlepinResource.get(join_path(path(uuid), 'export'), headers)
           end
 
           def entitlements(uuid)

data/app/lib/katello/resources/candlepin/owner.rb

@@ -12,8 +12,14 @@ module Katello
 
           # Set the contentPrefix at creation time so that the client will get
           # content only for the org it has been subscribed to
-          def create(key, description)
-            attrs = {:key => key, :displayName => description, :contentPrefix => "/#{key}/$env"}
+          def create(key, description, content_access_mode: 'org_environment')
+            attrs = {
+              :key => key,
+              :displayName => description,
+              :contentPrefix => "/#{key}/$env",
+              :contentAccessMode => content_access_mode,
+              :contentAccessModeList => ['entitlement', 'org_environment'].join(',')
+            }
             owner_json = self.post(path, attrs.to_json, self.default_headers).body
             JSON.parse(owner_json).with_indifferent_access
           end
@@ -36,6 +42,7 @@ module Katello
           def update(key, attrs)
             owner = find(key)
             owner.merge!(attrs)
+            owner.merge!(:contentAccessModeList => ['entitlement', 'org_environment'].join(','))
             self.put(path(key), JSON.generate(owner), self.default_headers).body
           end
 
@@ -53,7 +60,7 @@ module Katello
             Product.all(organization_name, [:id, :productContent])
           end
 
-          def destroy_imports(organization_name, wait_until_complete = false)
+          def destroy_imports(organization_name, wait_until_complete: false)
             response_json = self.delete(join_path(path(organization_name), 'imports'), self.default_headers)
             response = JSON.parse(response_json).with_indifferent_access
             if wait_until_complete && response['state'] == 'CREATED'

data/app/lib/katello/resources/candlepin/upstream_consumer.rb

@@ -40,17 +40,16 @@ module Katello
             raise ::Katello::Errors::UpstreamEntitlementGone
           end
 
-          def export(url, client_cert, client_key, ca_file)
+          def get_export(url, client_cert, client_key, ca_file)
             logger.debug "Sending GET request to upstream Candlepin: #{url}"
-            return resource(url, client_cert, client_key, ca_file).get
+            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).get
           rescue RestClient::Exception => e
             raise e
           end
 
           def update(url, client_cert, client_key, ca_file, attributes)
-            logger.debug "Sending POST request to upstream Candlepin: #{url} #{attributes.to_json}"
-
-            return resource(url, client_cert, client_key, ca_file).put(attributes.to_json,
+            logger.debug "Sending PUT request to upstream Candlepin: #{url} #{attributes.to_json}"
+            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).put(attributes.to_json,
                                                                        'accept' => 'application/json',
                                                                        'accept-language' => I18n.locale,
                                                                        'content-type' => 'application/json')

data/app/lib/katello/resources/candlepin/upstream_job.rb

@@ -0,0 +1,28 @@
+module Katello
+  module Resources
+    module Candlepin
+      class UpstreamJob < UpstreamCandlepinResource
+        class << self
+          NOT_FINISHED_STATES = %w(CREATED WAITING PENDING RUNNING).freeze unless defined? NOT_FINISHED_STATES
+          API_URL = 'https://subscription.rhsm.redhat.com/subscription'.freeze
+
+          def not_finished?(job)
+            NOT_FINISHED_STATES.include?(job[:state])
+          end
+
+          def get(id, upstream)
+            url = API_URL
+            response = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{path(id)}", upstream['idCert']['cert'],
+              upstream['idCert']['key'], nil)
+            job = JSON.parse(response)
+            job.with_indifferent_access
+          end
+
+          def path(id = nil)
+            "/jobs/#{id}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/resources/candlepin.rb

@@ -88,11 +88,17 @@ module Katello
         class << self
           delegate :[], to: :json_resource
 
-          def resource(url = self.site + self.path, client_cert = self.client_cert, client_key = self.client_key, ca_file = nil, options = {})
+          def resource(options = {}, url: self.site + self.path, client_cert: self.client_cert, client_key: self.client_key, ca_file: nil)
+            cert_store = OpenSSL::X509::Store.new
+            cert_store.add_file(ca_file) if ca_file
+
+            if proxy&.cacert&.present?
+              Foreman::Util.add_ca_bundle_to_store(proxy.cacert, cert_store)
+            end
             RestClient::Resource.new(url,
                                      :ssl_client_cert => OpenSSL::X509::Certificate.new(client_cert),
                                      :ssl_client_key => OpenSSL::PKey::RSA.new(client_key),
-                                     :ssl_ca_file => ca_file,
+                                     :ssl_cert_store => cert_store,
                                      :verify_ssl => ca_file ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE,
                                      :open_timeout => Setting[:manifest_refresh_timeout],
                                      :timeout => Setting[:manifest_refresh_timeout],
@@ -101,9 +107,9 @@ module Katello
                                     )
           end
 
-          def json_resource(url = self.site + self.path, client_cert = self.client_cert, client_key = self.client_key, ca_file = nil, options = {})
+          def json_resource(options = {}, url: self.site + self.path, client_cert: self.client_cert, client_key: self.client_key, ca_file: nil)
             options.deep_merge!(headers: self.default_headers)
-            resource(url, client_cert, client_key, ca_file, options)
+            resource(options, url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file)
           end
 
           def rest_client(_http_type = nil, method = :get, path = self.path)
@@ -111,7 +117,7 @@ module Katello
             self.consumer_secret = nil
             self.consumer_key = nil
 
-            resource(self.site + path, client_cert, client_key, nil, http_method: method)
+            resource({ http_method: method }, url: self.site + path, client_cert: client_cert, client_key: client_key, ca_file: nil)
           end
 
           def client_cert

data/app/lib/katello/resources/cdn/katello_cdn.rb

@@ -33,19 +33,9 @@ module Katello
           results = json_body['results']
 
           results.map do |repo|
-            arch = repo['arch']
-            arch = nil if arch == "noarch"
-            substitutions = {
-              :releasever => repo['minor'],
-              :basearch => arch
-            }.compact
-            path = substitutions.inject(content_path) do |path_url, (key, value)|
-              path_url.gsub("$#{key}", value)
-            end
-            {
-              path: path,
-              substitutions: substitutions
-            }
+            Katello::Content.substitute_content_path(arch: repo[:arch],
+                                                     releasever: repo[:minor],
+                                                     content_path: content_path)
           end
         end
 

data/app/lib/katello/resources/cdn.rb

@@ -38,17 +38,19 @@ module Katello
                                     :username,
                                     :password,
                                     :organization_label,
-                                    :ssl_ca_cert)
+                                    :ssl_ca_cert,
+                                    :custom_cdn)
 
           if options[:ssl_ca_cert].present?
-            begin
-              ca_cert = OpenSSL::X509::Certificate.new(options[:ssl_ca_cert])
-            rescue
-              raise _("Invalid SSL CA certificate given for CDN")
-            end
-
             @cert_store = OpenSSL::X509::Store.new
-            @cert_store.add_cert(ca_cert)
+            Foreman::Util.add_ca_bundle_to_store(options[:ssl_ca_cert], @cert_store)
+          elsif options[:ssl_ca_file]
+            @cert_store = OpenSSL::X509::Store.new
+            @cert_store.add_file(options[:ssl_ca_file])
+          end
+
+          if @cert_store && proxy&.cacert&.present?
+            Foreman::Util.add_ca_bundle_to_store(proxy.cacert, @cert_store)
           end
 
           @url = url
@@ -63,6 +65,9 @@ module Katello
             options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
             options[:ssl_ca_file] = self.ca_file
             self.new(cdn_configuration.url, options)
+          elsif cdn_configuration.custom_cdn?
+            options[:ssl_ca_cert] = cdn_configuration.ssl_ca
+            self.new(cdn_configuration.url, options)
           else
             options[:username] = cdn_configuration.username
             options[:password] = cdn_configuration.password
@@ -91,9 +96,9 @@ module Katello
           net.use_ssl = @uri.is_a?(URI::HTTPS)
 
           if @uri.is_a?(URI::HTTPS)
+            net.cert_store = @cert_store
             net.cert = @options[:ssl_client_cert]
             net.key = @options[:ssl_client_key]
-            net.ca_file = @options[:ssl_ca_file]
             net.cert_store = @cert_store
           end
 

data/app/lib/katello/util/candlepin_repository_checker.rb

@@ -0,0 +1,75 @@
+module Katello
+  module Util
+    module CandlepinRepositoryChecker
+      def self.check_repositories_for_promote!(content_view_version)
+        bad_repo = content_view_version.repositories.yum_type.find { |repo| !repository_exist_in_backend?(repo) }
+        return if bad_repo.blank?
+        item = _("Content View Version: '%{cvv}', Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name, cvv: content_view_version.name })
+
+        if bad_repo.redhat?
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove the invalid repository or try refreshing "\
+                 "the manifest before promoting. " % { item: item })
+        else
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Remove the invalid repository before promoting. " % { item: item })
+        end
+      end
+
+      def self.check_repository_for_sync!(repo)
+        return if !repo.yum? || repository_exist_in_backend?(repo)
+        item = _("Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: repo.name, product: repo.product.name })
+
+        if repo.redhat?
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove and re-enable the repository or try refreshing "\
+                 "the manifest before synchronizing. " % { item: item })
+        else
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Remove and recreate the repository before synchronizing. " % { item: item })
+        end
+      end
+
+      def self.repository_exist_in_backend?(repository)
+        return false if repository.root.content_id.blank?
+
+        ::Katello::Resources::Candlepin::Content.get(repository.organization.label, repository.root.content_id)
+        true
+      rescue RestClient::NotFound
+        false
+      end
+
+      def self.check_repositories_for_publish!(content_view)
+        if content_view.composite?
+          content_view.components.each do |cvv|
+            check_repositories_for_content_view_publish!(cvv.repositories, component_version: cvv)
+          end
+        else
+          check_repositories_for_content_view_publish!(content_view.repositories)
+        end
+      end
+
+      def self.check_repositories_for_content_view_publish!(repositories, component_version: nil)
+        bad_repo = repositories.yum_type.find { |repo| !repository_exist_in_backend?(repo) }
+        return if bad_repo.blank?
+        if component_version
+          item = _("Component Version: '%{cvv}', Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name, cvv: component_version.name })
+        else
+          item = _("Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name })
+        end
+        if bad_repo.redhat?
+          fail _("'%{item}' in this content view does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove the invalid repository or try refreshing "\
+                 "the manifest before publishing again. " % { item: item })
+        else
+          fail _("'%{item}' in this content view does not exist in the backend system [ Candlepin ]. "\
+                 " Remove the invalid repository before publishing again. " % { item: item })
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/util/errata.rb

@@ -46,19 +46,21 @@ module Katello
         end
       end
 
-      def filter_errata_by_pulp_href(errata, package_pulp_hrefs, source_repo_rpm_filenames)
-        return [] if package_pulp_hrefs.empty?
-        rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
-        srpms = Katello::Srpm.where(:pulp_id => package_pulp_hrefs)
-        rpm_filenames = rpms.map { |rpm| File.basename(rpm.filename) }
-        srpm_filenames = srpms.map { |srpm| File.basename(srpm.filename) }
+      def filter_errata_by_pulp_href(errata, content_pulp_hrefs, source_repo_rpm_filenames, source_repo_module_stream_specs)
+        return [] if content_pulp_hrefs.empty?
+
         source_repo_rpm_filenames = source_repo_rpm_filenames.map { |rpm| File.basename(rpm) }
+        rpm_filenames = Katello::Rpm.where(:pulp_id => content_pulp_hrefs).map { |rpm| File.basename(rpm.filename) }
+        srpm_filenames = Katello::Srpm.where(:pulp_id => content_pulp_hrefs).map { |srpm| File.basename(srpm.filename) }
+        module_stream_specs = Katello::ModuleStream.where(:pulp_id => content_pulp_hrefs).map(&:module_spec)
+
         matching_errata = []
         errata.each do |erratum|
-          # The erratum should be copied if package_pulp_hrefs has all of its packages that are available in the source repo.
-          rpms_in_erratum_and_source_repo = erratum.packages.pluck(:filename) & source_repo_rpm_filenames
-          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty? ||
-              erratum.packages.empty? || rpms_in_erratum_and_source_repo.empty?
+          # The erratum should be copied if content_pulp_hrefs has all of its packages/modules that are available in the source repo.
+          content_in_erratum_and_source_repo =
+            (erratum.packages.pluck(:filename) + erratum.module_stream_specs) & (source_repo_rpm_filenames + source_repo_module_stream_specs)
+          if (content_in_erratum_and_source_repo - rpm_filenames - srpm_filenames - module_stream_specs).empty? ||
+              (erratum.packages.empty? && erratum.module_streams.empty?) || content_in_erratum_and_source_repo.empty?
             matching_errata << erratum
           end
         end

data/app/lib/katello/util/search.rb

@@ -42,7 +42,6 @@ module Katello
         classes = get_subclasses(ActiveRecord::Base)
         classes = classes.select { |c| !ignore_list.include?(c.name) && c.respond_to?(:index) }
 
-        #we need index base classes first (TaskStatus) before child classes (PulpTaskStatus)
         initial_list = classes.select { |c| c.superclass == ActiveRecord::Base }
         subclass_list = classes - initial_list
         initial_list + subclass_list

data/app/lib/katello/validators/alternate_content_source_products_validator.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Validators
+    class AlternateContentSourceProductsValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :product_id
+            product = ::Katello::Product.find(value)
+            content_type = record.alternate_content_source.content_type
+            if product.repositories.with_type(content_type).has_url.empty?
+              record.errors[attribute] << N_("The product %{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/validators/content_view_environment_org_validator.rb

@@ -5,8 +5,11 @@ module Katello
         environment_id = record.respond_to?(:lifecycle_environment_id) ? record.lifecycle_environment_id : record.environment_id
         view = ContentView.where(:id => record.content_view_id).first
         environment = KTEnvironment.where(:id => environment_id).first
-        unless view.organization == environment.organization
-          record.errors[:base] << _("%{view_label} could not be promoted to %{environment_label} because the content view and the environment are not in the same organization!") % {:view_label => view.label, :environment_label => environment.label}
+        unless view && environment
+          record.errors[:base] << _("Content view environments must have both a content view and an environment")
+        end
+        unless view&.organization == environment&.organization
+          record.errors[:base] << _("%{view_label} could not be promoted to %{environment_label} because the content view and the environment are not in the same organization!") % {:view_label => view&.label, :environment_label => environment&.label}
         end
       end
     end

data/app/lib/katello/validators/content_view_environment_validator.rb

@@ -4,7 +4,6 @@ module Katello
       def validate(record)
         #support lifecycle_environment_id for foreman models
         environment_id = record.respond_to?(:lifecycle_environment_id) ? record.lifecycle_environment_id : record.environment_id
-
         if record.content_view_id
           view = ContentView.where(:id => record.content_view_id).first
           if environment_id
@@ -15,7 +14,7 @@ module Katello
             end
           end
           if view&.generated_for_repository?
-            record.errors[:base] << _("Generated Content views cannot be assigned to Host/Activation Keys")
+            record.errors[:base] << _("Generated content views cannot be assigned to hosts or activation keys")
           end
         end
       end

data/app/lib/katello/validators/generated_content_view_validator.rb

@@ -0,0 +1,16 @@
+module Katello
+  module Validators
+    class GeneratedContentViewValidator < ActiveModel::Validator
+      def validate(record)
+        record.content_view_environments.each do |cve|
+          if cve.content_view_id
+            view = ContentView.where(:id => cve.content_view_id).first
+            if view&.generated_for_repository?
+              record.errors[:base] << _("Content view '%{cv_name}' is a generated content view, which cannot be assigned to hosts or activation keys.") % { :cv_name => view.name }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/mailers/katello/errata_mailer.rb

@@ -33,8 +33,10 @@ module Katello
       ::User.as(user.login) do
         @content_view = options[:content_view]
         @environment = options[:environment]
-        @content_facets = Katello::Host::ContentFacet.where(:lifecycle_environment_id => @environment.id,
-                                                            :content_view_id => @content_view.id)
+        @content_facets = Katello::Host::ContentFacet.in_content_views_and_environments(
+          :lifecycle_environments => [@environment],
+          :content_views => [@content_view]
+        )
         @hosts = ::Host::Managed.authorized("view_hosts").where(:id => @content_facets.pluck(:host_id))
         @errata = @content_facets.map(&:installable_errata).flatten.uniq
 

data/app/models/katello/activation_key.rb

@@ -28,7 +28,7 @@ module Katello
     alias_method :lifecycle_environment, :environment
 
     before_validation :set_default_content_view, :unless => :persisted?
-
+    before_destroy :validate_destroyable!
     accepts_nested_attributes_for :purpose_addons
 
     validates_lengths_from_database
@@ -177,6 +177,17 @@ module Katello
       return_activation_keys_by_id(activation_keys.pluck(:id))
     end
 
+    def validate_destroyable!
+      unless organization.being_deleted?
+        if Parameter.where(name: 'kt_activation_keys').pluck(:value).any? { |value| value.split(",").include?(name) }
+          fail _("This activation key is associated to one or more Hosts/Hostgroups. "\
+                  "Search and unassociate Hosts/Hostgroups using params.kt_activation_keys ~ \"%{name}\" "\
+                  "before deleting." % {name: name})
+        end
+      end
+      true
+    end
+
     private
 
     def set_default_content_view