katello 3.5.2 → 3.6.0.rc1

data/app/models/katello/glue/candlepin/repository.rb

@@ -0,0 +1,31 @@
+module Katello
+  module Glue::Candlepin::Repository
+    CANDLEPIN_DOCKER_TYPE = "containerimage".freeze
+    CANDLEPIN_OSTREE_TYPE = "ostree".freeze
+
+    def self.included(base)
+      base.send :include, InstanceMethods
+      # required for GPG key url generation
+      base.send :include, Rails.application.routes.url_helpers
+    end
+
+    module InstanceMethods
+      def should_update_content?
+        (self.gpg_key_id_was.nil? && !self.gpg_key_id.nil? && self.content.gpgUrl == '') ||
+            (!self.gpg_key_id_was.nil? && self.gpg_key_id.nil? && self.content.gpgUrl != '')
+      end
+
+      def yum_gpg_key_url
+        # if the repo has a gpg key return a url to access it
+        if (gpg_key && gpg_key.content.present?)
+          host = Facter.value(:fqdn) || SETTINGS[:fqdn]
+          gpg_key_content_api_repository_url(self, :host => host + "/katello", :protocol => 'https')
+        end
+      end
+
+      def custom_content_label
+        "#{organization.label} #{product.label} #{label}".gsub(/\s/, "_")
+      end
+    end
+  end
+end

data/app/models/katello/glue/provider.rb

@@ -53,24 +53,6 @@ module Katello
         sync_times.last
       end
 
-      def owner_regenerate_upstream_certificates(upstream)
-        if !upstream['idCert'] || !upstream['idCert']['cert'] || !upstream['idCert']['key']
-          Rails.logger.error "Upstream identity certificate not available"
-          fail _("Upstream identity certificate not available")
-        end
-
-        # Default to Red Hat
-        url = upstream['apiUrl'] || 'https://subscription.rhn.redhat.com/subscription/consumers/'
-
-        # TODO: wait until ca_path is supported
-        #       https://github.com/L2G/rest-client-fork/pull/8
-        #ca_file = '/etc/candlepin/certs/upstream/subscription.rhn.stage.redhat.com.crt'
-        ca_file = nil
-
-        Resources::Candlepin::UpstreamConsumer.update("#{url}#{upstream['uuid']}/certificates", upstream['idCert']['cert'],
-                                                      upstream['idCert']['key'], ca_file, {})
-      end
-
       def owner_upstream_update(upstream, _options)
         if !upstream['idCert'] || !upstream['idCert']['cert'] || !upstream['idCert']['key']
           Rails.logger.error "Upstream identity certificate not available"
@@ -141,9 +123,24 @@ module Katello
         ::Foreman::Logging.logger('katello/manifest_import_logger')
       end
 
+      def update_product_content_from_cp(katello_and_cp_ids)
+        katello_and_cp_ids.each do |id_pair|
+          attrs = Resources::Candlepin::Product.get(self.organization.label, id_pair.second, %w(productContent)).first
+          product_content_attrs = attrs.delete(:productContent) || []
+          product = ::Katello::Product.find(id_pair.first)
+          Glue::Candlepin::Product.import_product_content(product, product_content_attrs)
+        end
+      end
+
       # TODO: break up method
       def import_products_from_cp # rubocop:disable MethodLength
-        product_in_katello_ids = self.organization.providers.redhat.first.products.pluck("cp_id")
+        db_and_cp_ids = self.organization.providers.redhat.first.products.pluck(:id, :cp_id)
+
+        # this method only imports products which are not already in Katello
+        # no need for a full import on them - just update the product content
+        update_product_content_from_cp(db_and_cp_ids)
+
+        product_in_katello_ids = db_and_cp_ids.map(&:second)
         products_in_candlepin_ids = []
 
         marketing_to_engineering_product_ids_mapping.each do |marketing_product_id, engineering_product_ids|

data/app/models/katello/glue/pulp/repo.rb

@@ -101,6 +101,10 @@ module Katello
         end
       end
 
+      def srpm_count
+        pulp_repo_facts['content_unit_counts']['srpm']
+      end
+
       def uri
         uri = URI.parse(SETTINGS[:katello][:pulp][:url])
         "https://#{uri.host}/pulp/repos/#{relative_path}"
@@ -140,6 +144,8 @@ module Katello
             importer = Runcible::Models::YumImporter.new
           when Repository::PUPPET_TYPE
             importer = Runcible::Models::PuppetImporter.new
+          when Repository::DEB_TYPE
+            importer = Runcible::Models::DebImporter.new
           end
         end
 
@@ -159,7 +165,7 @@ module Katello
         when Repository::YUM_TYPE
           Runcible::Models::YumImporter.new(yum_importer_values(capsule))
         when Repository::FILE_TYPE
-          Runcible::Models::IsoImporter.new(importer_ssl_options(capsule).merge(:feed => importer_feed_url(capsule)))
+          Runcible::Models::IsoImporter.new(importer_connection_options(capsule).merge(:feed => importer_feed_url(capsule)))
         when Repository::PUPPET_TYPE
           Runcible::Models::PuppetImporter.new(puppet_importer_values(capsule))
         when Repository::DOCKER_TYPE
@@ -167,12 +173,14 @@ module Katello
           options[:upstream_name] = capsule.default_capsule? ? self.docker_upstream_name : self.container_repository_name
           options[:feed] = docker_feed_url(capsule)
           options[:enable_v1] = false
-          Runcible::Models::DockerImporter.new(importer_ssl_options(capsule).merge(options))
+          Runcible::Models::DockerImporter.new(importer_connection_options(capsule).merge(options))
         when Repository::OSTREE_TYPE
-          options = importer_ssl_options(capsule)
+          options = importer_connection_options(capsule)
           options[:depth] = capsule.default_capsule? ? compute_ostree_upstream_sync_depth : ostree_capsule_sync_depth
           options[:feed] = self.importer_feed_url(capsule)
           Runcible::Models::OstreeImporter.new(options)
+        when Repository::DEB_TYPE
+          Runcible::Models::DebImporter.new(deb_importer_values(capsule))
         else
           fail _("Unexpected repo type %s") % self.content_type
         end
@@ -207,7 +215,11 @@ module Katello
           :download_policy => new_download_policy,
           :remove_missing => capsule.default_capsule? ? self.mirror_on_sync? : true
         }
-        config.merge(importer_ssl_options(capsule))
+        config.merge(importer_connection_options(capsule))
+      end
+
+      def proxy_host_value
+        self.ignore_global_proxy ? "" : nil
       end
 
       def puppet_importer_values(capsule)
@@ -215,10 +227,20 @@ module Katello
           :feed => self.importer_feed_url(capsule),
           :remove_missing => capsule.default_capsule? ? self.mirror_on_sync? : true
         }
-        config.merge(importer_ssl_options(capsule))
+        config.merge(importer_connection_options(capsule))
+      end
+
+      def deb_importer_values(capsule)
+        config = {
+          feed: self.importer_feed_url(capsule),
+          releases: self.deb_releases,
+          components: self.deb_components,
+          architectures: self.deb_architectures
+        }
+        config.merge(importer_connection_options(capsule))
       end
 
-      def importer_ssl_options(capsule = SmartProxy.default_capsule!)
+      def importer_connection_options(capsule = SmartProxy.default_capsule!)
         if !capsule.default_capsule?
           ueber_cert = ::Cert::Certs.ueber_cert(organization)
           importer_options = {
@@ -230,13 +252,15 @@ module Katello
           importer_options = {
             :ssl_client_cert => self.product.certificate,
             :ssl_client_key => self.product.key,
-            :ssl_ca_cert => Katello::Repository.feed_ca_cert(url)
+            :ssl_ca_cert => Katello::Repository.feed_ca_cert(url),
+            :proxy_host => self.proxy_host_value
           }
         else
           importer_options = {
             :ssl_client_cert => nil,
             :ssl_client_key => nil,
-            :ssl_ca_cert => nil
+            :ssl_ca_cert => nil,
+            :proxy_host => self.proxy_host_value
           }
         end
         unless self.is_a?(::Katello::ContentViewPuppetEnvironment)
@@ -264,8 +288,7 @@ module Katello
           distributors = [yum_dist, export_dist]
           distributors << clone_dist if capsule.default_capsule?
         when Repository::FILE_TYPE
-          dist = Runcible::Models::IsoDistributor.new(true, true)
-          dist.auto_publish = true
+          dist = Runcible::Models::IsoDistributor.new(self.relative_path, self.unprotected, true, auto_publish: true)
           distributors = [dist]
         when Repository::PUPPET_TYPE
           capsule ||= SmartProxy.default_capsule!
@@ -295,6 +318,15 @@ module Katello
 
           dist = Runcible::Models::OstreeDistributor.new(options)
           distributors = [dist]
+        when Repository::DEB_TYPE
+          options = {
+            id: self.pulp_id,
+            auto_publish: true
+          }
+          http = self.unprotected
+          https = true
+          dist = Runcible::Models::DebDistributor.new(self.relative_path, http, https, options)
+          distributors = [dist]
         else
           fail _("Unexpected repo type %s") % self.content_type
         end
@@ -314,6 +346,8 @@ module Katello
           Runcible::Models::DockerImporter::ID
         when Repository::OSTREE_TYPE
           Runcible::Models::OstreeImporter::ID
+        when Repository::DEB_TYPE
+          Runcible::Models::DebImporter::ID
         else
           fail _("Unexpected repo type %s") % self.content_type
         end
@@ -390,8 +424,9 @@ module Katello
 
       def pulp_update_needed?
         changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
-                                   upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth)
+                                   upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignore_global_proxy)
         changeable_attributes << "name" if docker?
+        changeable_attributes += %w(deb_releases deb_components deb_architectures) if deb?
         changeable_attributes.any? { |key| previous_changes.key?(key) }
       end
 
@@ -573,6 +608,8 @@ module Katello
           "ostree"
         when Repository::FILE_TYPE
           "iso"
+        when Repository::DEB_TYPE
+          "deb"
         end
       end
 
@@ -622,6 +659,10 @@ module Katello
         self.content_type == Repository::OSTREE_TYPE
       end
 
+      def deb?
+        self.content_type == Repository::DEB_TYPE
+      end
+
       def published?
         distributors.map { |dist| dist['last_publish'] }.compact.any?
       end
@@ -652,7 +693,7 @@ module Katello
         return false if last_sync.nil?
         return true if last_publish.nil?
 
-        DateTime.parse(last_sync) >= DateTime.parse(last_publish)
+        Time.parse(last_sync) >= Time.parse(last_publish)
       end
 
       def last_sync_task
@@ -723,31 +764,63 @@ module Katello
       if docker?
         "#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}/#{container_repository_name}"
       elsif file?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/isos/#{pulp_id}/"
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/isos/#{relative_path}/"
       elsif puppet?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/puppet/#{pulp_id}/"
       elsif ostree?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/ostree/web/#{relative_path}"
+      elsif deb?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/deb/#{relative_path}"
       else
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/repos/#{relative_path}/"
       end
     end
 
-    def index_content(full_index = false)
-      if self.yum?
+    def index_yum_content(full_index = false)
+      if self.master?
         Katello::Rpm.import_for_repository(self, full_index)
+        Katello::Srpm.import_for_repository(self, full_index)
         Katello::Erratum.import_for_repository(self)
         Katello::PackageGroup.import_for_repository(self)
         self.import_distribution_data
+      else
+        index_linked_repo
+      end
+    end
+
+    def index_linked_repo
+      if (base_repo = self.target_repository)
+        Rpm.copy_repository_associations(base_repo, self)
+        Erratum.copy_repository_associations(base_repo, self)
+        PackageGroup.copy_repository_associations(base_repo, self)
+        self.update_attributes!(
+          :distribution_version => base_repo.distribution_version,
+          :distribution_arch => base_repo.distribution_arch,
+          :distribution_family => base_repo.distribution_family,
+          :distribution_variant => base_repo.distribution_variant,
+          :distribution_uuid => base_repo.distribution_uuid,
+          :distribution_bootable => base_repo.distribution_bootable
+        )
+      else
+        Rails.logger.error("Cannot index #{self.id}, no target repository found.")
+      end
+    end
+
+    def index_content(full_index = false)
+      if self.yum?
+        index_yum_content(full_index)
       elsif self.docker?
         Katello::DockerManifest.import_for_repository(self)
-        Katello::DockerTag.import_for_repository(self, true)
+        Katello::DockerManifestList.import_for_repository(self)
+        Katello::DockerTag.import_for_repository(self)
       elsif self.puppet?
         Katello::PuppetModule.import_for_repository(self)
       elsif self.ostree?
         Katello::OstreeBranch.import_for_repository(self)
       elsif self.file?
         Katello::FileUnit.import_for_repository(self)
+      elsif self.deb?
+        Katello::Deb.import_for_repository(self)
       end
       true
     end

data/app/models/katello/host/content_facet.rb

@@ -9,14 +9,14 @@ module Katello
       belongs_to :lifecycle_environment, :inverse_of => :content_facets, :class_name => "Katello::KTEnvironment"
       belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :content_facets
 
-      has_many :applicable_errata, :through => :content_facet_errata, :class_name => "Katello::Erratum", :source => :erratum
       has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :applicable_errata, :through => :content_facet_errata, :class_name => "Katello::Erratum", :source => :erratum
 
-      has_many :bound_repositories, :through => :content_facet_repositories, :class_name => "Katello::Repository", :source => :repository
       has_many :content_facet_repositories, :class_name => "Katello::ContentFacetRepository", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :bound_repositories, :through => :content_facet_repositories, :class_name => "Katello::Repository", :source => :repository
 
-      has_many :applicable_rpms, :through => :content_facet_applicable_rpms, :class_name => "Katello::Rpm", :source => :rpm
       has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :applicable_rpms, :through => :content_facet_applicable_rpms, :class_name => "Katello::Rpm", :source => :rpm
 
       validates :content_view, :presence => true, :allow_blank => false
       validates :lifecycle_environment, :presence => true, :allow_blank => false
@@ -52,7 +52,7 @@ module Katello
                 else
                   self.bound_repositories.pluck(:id)
                 end
-        self.applicable_errata.in_repositories(repos).uniq
+        self.applicable_errata.in_repositories(repos)
       end
 
       def installable_rpms(env = nil, content_view = nil)
@@ -61,7 +61,7 @@ module Katello
                 else
                   self.bound_repositories.pluck(:id)
                 end
-        self.applicable_rpms.in_repositories(repos).uniq
+        self.applicable_rpms.in_repositories(repos)
       end
 
       def errata_counts
@@ -148,7 +148,7 @@ module Katello
       def self.with_non_installable_errata(errata)
         subquery = Katello::Erratum.select("#{Katello::Erratum.table_name}.id").ids_installable_for_hosts
         .where("#{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::Host::ContentFacet.table_name}.id").to_sql
-        self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata).where("#{Katello::Erratum.table_name}.id NOT IN (#{subquery})").uniq
+        self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata).where("#{Katello::Erratum.table_name}.id NOT IN (#{subquery})").distinct
       end
 
       def self.with_applicable_errata(errata)

data/app/models/katello/host/info_provider.rb

@@ -28,7 +28,7 @@ module Katello
           'label' => host.content_view.try(:label),
           'latest-version' => host.content_view.try(:latest_version),
           'version' => content_version.try(:version),
-          'published' => content_version.try(:created_at),
+          'published' => content_version.try(:created_at).try(:time),
           'components' => content_view_components
         }
 
@@ -43,7 +43,7 @@ module Katello
           cv_label = cv.component_version.content_view.label
           components[cv_label] = {}
           components[cv_label]['version'] = cv.component_version.try(:version)
-          components[cv_label]['published'] = cv.component_version.try(:created_at)
+          components[cv_label]['published'] = cv.component_version.try(:created_at).try(:time)
         end
         components
       end

data/app/models/katello/host/subscription_facet.rb

@@ -7,11 +7,11 @@ module Katello
       belongs_to :user, :inverse_of => :subscription_facets, :class_name => "::User"
       belongs_to :hypervisor_host, :class_name => "::Host::Managed", :foreign_key => "hypervisor_host_id"
 
-      has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
+      has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
 
-      has_many :pools, :through => :subscription_facet_pools, :class_name => "Katello::Pool"
       has_many :subscription_facet_pools, :class_name => "Katello::SubscriptionFacetPool", :dependent => :destroy, :inverse_of => :subscription_facet
+      has_many :pools, :through => :subscription_facet_pools, :class_name => "Katello::Pool"
       validates :host, :presence => true, :allow_blank => false
 
       DEFAULT_TYPE = 'system'.freeze
@@ -140,7 +140,7 @@ module Katello
       def self.update_facts(host, rhsm_facts)
         return if host.build? || rhsm_facts.nil?
         rhsm_facts[:_type] = RhsmFactName::FACT_TYPE
-        rhsm_facts[:_timestamp] = DateTime.now.to_s
+        rhsm_facts[:_timestamp] = Time.now.to_s
         host.import_facts(rhsm_facts)
       end
 
@@ -192,7 +192,7 @@ module Katello
 
       def self.find_host(facts, organization)
         host_name = propose_existing_hostname(facts)
-        hosts = ::Host.unscoped.where(:name => host_name)
+        hosts = ::Host.where(:name => host_name)
 
         return nil if hosts.empty? #no host exists
         if hosts.where("organization_id = #{organization.id} OR organization_id is NULL").empty? #not in the correct org

data/app/models/katello/kt_environment.rb

@@ -58,7 +58,7 @@ module Katello
                                               :dependent => :destroy, :inverse_of => :lifecycle_environment
 
     # RAILS3458: before_destroys before associations. see http://tinyurl.com/rails3458
-    before_destroy :deletable?, :prepend => true
+    before_destroy :assert_deletable, :prepend => true
 
     scope(:not_in_capsule,
       lambda do |capsule|
@@ -80,7 +80,7 @@ module Katello
     end
 
     def default_content_view
-      self.default_content_view_version.try(:content_view, nil)
+      self.default_content_view_version.try(:content_view)
     end
 
     def default_content_view_version
@@ -140,6 +140,10 @@ module Katello
       self.promoting.exists?
     end
 
+    def assert_deletable
+      throw :abort unless deletable?
+    end
+
     def deletable?
       return true if self.organization.nil? || self.organization.being_deleted?
 

data/app/models/katello/package_group.rb

@@ -4,8 +4,8 @@ module Katello
 
     CONTENT_TYPE = "package_group".freeze
 
-    has_many :repositories, :through => :repository_package_groups, :class_name => "Katello::Repository"
     has_many :repository_package_groups, :class_name => "Katello::RepositoryPackageGroup", :dependent => :destroy, :inverse_of => :package_group
+    has_many :repositories, :through => :repository_package_groups, :class_name => "Katello::Repository"
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :uuid, :rename => :id, :complete_value => true