katello 3.3.2 → 3.4.0.rc1

data/app/models/katello/content_view_history.rb

@@ -22,7 +22,7 @@ module Katello
     alias_method :version, :content_view_version
     alias_attribute :description, :notes
 
-    scoped_search :on => :name, :in => :environment, :rename => :environment, :complete_value => true
+    scoped_search :on => :name, :relation => :environment, :rename => :environment, :complete_value => true
 
     enum action: {
       publish: 1,

data/app/models/katello/content_view_puppet_environment.rb

@@ -27,6 +27,8 @@ module Katello
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates :puppet_environment, :presence => true, :if => :environment
 
+    before_validation :set_pulp_id
+
     scope :non_archived, -> { where('environment_id is not NULL') }
     scope :archived, -> { where('environment_id is NULL') }
 
@@ -84,8 +86,14 @@ module Katello
       end
     end
 
-    def self.generate_pulp_id(organization_label, env_label, view_label, version)
-      [organization_label, env_label, view_label, version].compact.join("-").gsub(/[^-\w]/, "_")
+    def set_pulp_id
+      if self.environment
+        label = "#{self.content_view.label}-#{self.environment.label}-puppet-#{SecureRandom.uuid}"
+      else
+        version = self.content_view_version.version.gsub('.', '_')
+        label = "#{self.content_view.label}-v#{version}-puppet-#{SecureRandom.uuid}"
+      end
+      self.pulp_id ||= "#{self.organization.id}-#{label}"
     end
 
     def index_content(puppet_module_uuids)

data/app/models/katello/content_view_puppet_module.rb

@@ -14,7 +14,7 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :author, :complete_value => true
     scoped_search :on => :uuid, :complete_value => true
-    scoped_search :on => :name, :in => :content_view, :rename => :content_view_name
+    scoped_search :on => :name, :relation => :content_view, :rename => :content_view_name
 
     def puppet_module
       PuppetModule.find_by_uuid(self.uuid)

data/app/models/katello/content_view_version.rb

@@ -45,9 +45,9 @@ module Katello
       joins(:content_view).where("#{Katello::ContentView.table_name}.organization_id" => organization_id)
     end
 
-    scoped_search :on => :content_view_id, :only_explicit => true
+    scoped_search :on => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :major, :rename => :version, :complete_value => true, :ext_method => :find_by_version
-    scoped_search :in => :repositories, :on => :name, :rename => :repository, :complete_value => true
+    scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true
 
     def self.find_by_version(_key, operator, value)
       conditions = ""

data/app/models/katello/docker_manifest.rb

@@ -8,7 +8,7 @@ module Katello
 
     CONTENT_TYPE = Pulp::DockerManifest::CONTENT_TYPE
     scoped_search :on => :name, :complete_value => true
-    scoped_search :in => :docker_tags, :on => :name, :rename => :tag, :complete_value => true, :only_explicit => true
+    scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true, :only_explicit => true
 
     def self.repository_association_class
       RepositoryDockerManifest

data/app/models/katello/docker_tag.rb

@@ -6,11 +6,11 @@ module Katello
     belongs_to :repository, :inverse_of => :docker_tags, :class_name => "Katello::Repository"
 
     scoped_search :on => :name, :complete_value => true, :rename => :tag
-    scoped_search :in => :docker_manifest, :on => :name, :rename => :manifest,
+    scoped_search :relation => :docker_manifest, :on => :name, :rename => :manifest,
       :complete_value => true, :only_explicit => false
-    scoped_search :in => :docker_manifest, :on => :digest, :rename => :digest,
+    scoped_search :relation => :docker_manifest, :on => :digest, :rename => :digest,
       :complete_value => false, :only_explicit => true
-    scoped_search :in => :repository, :on => :name, :rename => :repository,
+    scoped_search :relation => :repository, :on => :name, :rename => :repository,
       :complete_value => true, :only_explicit => true
 
     scope :in_repositories, ->(repos) { where(:repository_id => repos) }

data/app/models/katello/erratum.rb

@@ -27,10 +27,10 @@ module Katello
     scoped_search :on => :issued, :complete_value => true
     scoped_search :on => :updated, :complete_value => true
     scoped_search :on => :reboot_suggested, :complete_value => true
-    scoped_search :in => :cves, :on => :cve_id, :rename => :cve
-    scoped_search :in => :bugzillas, :on => :bug_id, :rename => :bug
-    scoped_search :in => :packages, :on => :nvrea, :rename => :package, :complete_value => true
-    scoped_search :in => :packages, :on => :name, :rename => :package_name, :complete_value => true
+    scoped_search :relation => :cves, :on => :cve_id, :rename => :cve
+    scoped_search :relation => :bugzillas, :on => :bug_id, :rename => :bug
+    scoped_search :relation => :packages, :on => :nvrea, :rename => :package, :complete_value => true
+    scoped_search :relation => :packages, :on => :name, :rename => :package_name, :complete_value => true
 
     before_save lambda { |erratum| erratum.title = erratum.title.truncate(255) unless erratum.title.blank? }
 

data/app/models/katello/file_unit.rb

@@ -12,7 +12,7 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :path, :complete_value => true
     scoped_search :on => :checksum
-    scoped_search :in => :repositories, :on => :name, :rename => :repository, :complete_value => true
+    scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true
 
     def self.default_sort
       order(:name)

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

@@ -28,12 +28,12 @@ module Katello
 
       def get_key_pools
         key_pools = Resources::Candlepin::ActivationKey.get(self.cp_id)[0][:pools]
-        pools = []
-        key_pools.each do |key_pool|
-          key_pool[:pool][:amount] = (key_pool[:quantity] ? key_pool[:quantity] : 0)
-          pools << key_pool[:pool]
+        key_pools.map do |key_pool|
+          {
+            :amount => (key_pool[:quantity] ? key_pool[:quantity] : 0),
+            :id => key_pool[:poolId]
+          }.with_indifferent_access
         end
-        pools
       end
 
       def import_pools
@@ -63,12 +63,14 @@ module Katello
         self.import_pools
       end
 
-      def set_content_override(content_label, name, value = nil)
-        Resources::Candlepin::ActivationKey.update_content_override(self.cp_id, content_label, name, value)
+      def set_content_overrides(overrides)
+        Resources::Candlepin::ActivationKey.update_content_overrides(self.cp_id, overrides.map(&:to_entitlement_hash))
       end
 
       def content_overrides
-        Resources::Candlepin::ActivationKey.content_overrides(self.cp_id)
+        Resources::Candlepin::ActivationKey.content_overrides(self.cp_id).map do |overrides|
+          ::Katello::ContentOverride.from_entitlement_hash(overrides)
+        end
       end
 
       private

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

@@ -13,33 +13,13 @@ module Katello
       def content
         return @content unless @content.nil?
         unless self.content_id.nil?
-          @content = Katello::Candlepin::Content.find(self.content_id)
+          @content = Katello::Candlepin::Content.find(self.organization.label, self.content_id)
         end
         @content
       rescue RestClient::ResourceNotFound, RestClient::BadRequest
         nil
       end
 
-      def create_content
-        #only used for custom content
-        fail 'Can only create content for custom providers' if self.product.provider.redhat_provider?
-        new_content = Candlepin::ProductContent.new(
-          :content => {
-            :name => self.name,
-            :contentUrl => Glue::Pulp::Repos.custom_content_path(self.product, self.label),
-            :type => self.content_type,
-            :label => self.custom_content_label,
-            :vendor => Provider::CUSTOM
-          },
-          :enabled => true
-        )
-        new_content.create
-        self.product.add_content new_content
-        self.content_id = new_content.content.id
-        self.cp_label = new_content.content.label
-        new_content.content
-      end
-
       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 != '')

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

@@ -21,7 +21,9 @@ module Katello
       end
 
       def owner_details
-        Resources::Candlepin::Owner.find self.label
+        details = Resources::Candlepin::Owner.find self.label
+        details['virt_who'] = self.subscriptions.using_virt_who.any?
+        details
       end
 
       def service_level

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

@@ -94,7 +94,7 @@ module Katello
       end
 
       def import_data
-        pool_attributes = {}
+        pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data
         product_attributes = pool_json["productAttributes"] + pool_json["attributes"]
 
@@ -126,6 +126,8 @@ module Katello
           pool_attributes[:unmapped_guest] = true
         end
 
+        pool_attributes[:virt_who] = pool_attributes['virt_limit'] != "0" && !pool_attributes['virt_limit'].nil? && subscription.try(:redhat?)
+
         exceptions = pool_attributes.keys.map(&:to_sym) - self.attribute_names.map(&:to_sym)
         self.update_attributes(pool_attributes.except!(*exceptions))
         self.save!

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

@@ -16,11 +16,10 @@ module Katello
         lazy_accessor :productContent, :multiplier, :href, :attrs,
           :initializer => (lambda do |_s|
             convert_from_cp_fields(
-              Resources::Candlepin::Product.get(cp_id, PRODUCT_ATTRS)[0]
+              Resources::Candlepin::Product.get(self.organization.label, cp_id, PRODUCT_ATTRS)[0]
             )
           end)
 
-        # Certificate for this product - used for SSL certificate and key
         lazy_accessor :product_certificate,
           :initializer => lambda { |_s| Resources::Candlepin::Product.product_certificate(cp_id, self.organization.label) },
           :unless => lambda { |_s| cp_id.nil? }
@@ -135,14 +134,10 @@ module Katello
       end
 
       def add_content(content)
-        Resources::Candlepin::Product.add_content self.cp_id, content.content.id, true
+        Resources::Candlepin::Product.add_content(self.organization.label, self.cp_id, content.content.id, true)
         self.productContent << content
       end
 
-      def remove_content_by_id(content_id)
-        Resources::Candlepin::Product.remove_content cp_id, content_id
-      end
-
       def product_content_by_id(content_id)
         self.productContent.find { |pc| pc.content.id == content_id }
       end

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

@@ -63,6 +63,24 @@ 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,7 +159,7 @@ module Katello
           products_in_candlepin_ids << marketing_product_id
           products_in_candlepin_ids.concat(engineering_product_ids)
           added_eng_products = (engineering_product_ids - product_in_katello_ids).map do |id|
-            Resources::Candlepin::Product.get(id)[0]
+            Resources::Candlepin::Product.get(self.organization.label, id)[0]
           end
           adjusted_eng_products = []
           added_eng_products.each do |product_attrs|

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

@@ -150,7 +150,7 @@ module Katello
         raise PulpErrors::ServiceUnavailable.new(message, e)
       end
 
-      def generate_importer(capsule = SmartProxy.default_capsule)
+      def generate_importer(capsule = SmartProxy.default_capsule!)
         case self.content_type
         when Repository::YUM_TYPE
           Runcible::Models::YumImporter.new(yum_importer_values(capsule))
@@ -161,13 +161,13 @@ module Katello
           Runcible::Models::PuppetImporter.new(importer_ssl_options(capsule).merge(options))
         when Repository::DOCKER_TYPE
           options = {}
-          options[:upstream_name] = capsule.default_capsule? ? self.docker_upstream_name : self.pulp_id
+          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))
         when Repository::OSTREE_TYPE
           options = importer_ssl_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)
         else
@@ -175,7 +175,7 @@ module Katello
         end
       end
 
-      def docker_feed_url(capsule = SmartProxy.default_capsule)
+      def docker_feed_url(capsule = SmartProxy.default_capsule!)
         pulp_uri = URI.parse(SETTINGS[:katello][:pulp][:url])
         if capsule.default_capsule?
           self.url if self.respond_to?(:url)
@@ -184,7 +184,7 @@ module Katello
         end
       end
 
-      def importer_feed_url(capsule = SmartProxy.default_capsule)
+      def importer_feed_url(capsule = SmartProxy.default_capsule!)
         if capsule.default_capsule?
           self.url if self.respond_to?(:url)
         else
@@ -207,7 +207,7 @@ module Katello
         config.merge(importer_ssl_options(capsule))
       end
 
-      def importer_ssl_options(capsule = SmartProxy.default_capsule)
+      def importer_ssl_options(capsule = SmartProxy.default_capsule!)
         if !capsule.default_capsule?
           ueber_cert = ::Cert::Certs.ueber_cert(organization)
           importer_options = {
@@ -230,13 +230,15 @@ module Katello
         end
         unless self.is_a?(::Katello::ContentViewPuppetEnvironment)
           importer_options.merge!(:ssl_validation => verify_ssl_on_sync?)
-          importer_options[:basic_auth_username] = upstream_username if upstream_username.present?
-          importer_options[:basic_auth_password] = upstream_password if upstream_password.present?
+          if capsule.default_capsule?
+            importer_options.merge!(:basic_auth_username => upstream_username,
+                                    :basic_auth_password => upstream_password)
+          end
         end
         importer_options
       end
 
-      def generate_distributors(capsule = SmartProxy.default_capsule)
+      def generate_distributors(capsule = SmartProxy.default_capsule!)
         case self.content_type
         when Repository::YUM_TYPE
           yum_dist_id = self.pulp_id
@@ -255,7 +257,7 @@ module Katello
           dist.auto_publish = true
           distributors = [dist]
         when Repository::PUPPET_TYPE
-          capsule ||= SmartProxy.default_capsule
+          capsule ||= SmartProxy.default_capsule!
           dist_options = { :id => self.pulp_id, :auto_publish => true }
           repo_path =  File.join(capsule.puppet_path,
                                  Environment.construct_name(self.organization,
@@ -270,13 +272,16 @@ module Katello
 
           distributors = [puppet_dist, puppet_install_dist]
         when Repository::DOCKER_TYPE
-          options = { :protected => !self.unprotected, :id => self.pulp_id, :auto_publish => true}
+          options = { :protected => !self.unprotected, :id => self.pulp_id, :auto_publish => true,
+                      :repo_registry_id => container_repository_name}
           docker_dist = Runcible::Models::DockerDistributor.new(options)
           distributors = [docker_dist]
         when Repository::OSTREE_TYPE
           options = { :id => self.pulp_id,
                       :auto_publish => true,
-                      :relative_path => relative_path }
+                      :relative_path => relative_path,
+                      :depth => self.compute_ostree_upstream_sync_depth }
+
           dist = Runcible::Models::OstreeDistributor.new(options)
           distributors = [dist]
         else
@@ -373,7 +378,8 @@ module Katello
       end
 
       def pulp_update_needed?
-        changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync)
+        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)
         changeable_attributes << "name" if docker?
         changeable_attributes.any? { |key| previous_changes.key?(key) }
       end
@@ -403,8 +409,11 @@ module Katello
         fail "Invalid content type #{content_type} sent. It needs to be one of #{content_classes.keys}"\
                                                                        unless content_classes[content_type]
         criteria = {}
-        if content_type == Runcible::Extensions::Rpm.content_type
+        case content_type
+        when Runcible::Extensions::Rpm.content_type
           criteria[:fields] = Pulp::Rpm::PULP_SELECT_FIELDS
+        when Runcible::Extensions::Errata.content_type
+          criteria[:fields] = Pulp::Erratum::PULP_SELECT_FIELDS
         end
 
         if filter_clauses && !filter_clauses.empty?
@@ -433,7 +442,9 @@ module Katello
 
           # Since the rpms will be copied above, during the copy of errata and package groups,
           # include the copy_children flag to request that pulp skip copying them again.
-          events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id, :copy_children => false)
+          events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id,
+                                                    :fields => Pulp::Erratum::PULP_SELECT_FIELDS,
+                                                    :copy_children => false)
           events << Katello.pulp_server.extensions.package_group.copy(self.pulp_id, to_repo.pulp_id, :copy_children => false)
           events << clone_file_metadata(to_repo)
         end
@@ -447,8 +458,11 @@ module Katello
 
       def unassociate_by_filter(content_type, filter_clauses)
         criteria = {:type_ids => [content_type], :filters => {:unit => filter_clauses}}
-        if content_type == Katello.pulp_server.extensions.rpm.content_type
+        case content_type
+        when Katello.pulp_server.extensions.rpm.content_type
           criteria[:fields] = { :unit => Pulp::Rpm::PULP_SELECT_FIELDS}
+        when Katello.pulp_server.extensions.errata.content_type
+          criteria[:fields] = { :unit => Pulp::Erratum::PULP_SELECT_FIELDS}
         end
         Katello.pulp_server.extensions.repository.unassociate_units(self.pulp_id, criteria)
       end
@@ -690,7 +704,7 @@ module Katello
       pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : SETTINGS[:katello][:pulp][:url])
       scheme   = (self.unprotected && !force_https) ? 'http' : 'https'
       if docker?
-        "#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}/#{pulp_id}"
+        "#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}/#{container_repository_name}"
       elsif file?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/isos/#{pulp_id}/"
       elsif puppet?
@@ -702,9 +716,9 @@ module Katello
       end
     end
 
-    def index_content
+    def index_content(full_index = false)
       if self.yum?
-        Katello::Rpm.import_for_repository(self)
+        Katello::Rpm.import_for_repository(self, full_index)
         Katello::Erratum.import_for_repository(self)
         Katello::PackageGroup.import_for_repository(self)
         self.import_distribution_data

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

@@ -205,13 +205,6 @@ module Katello
         end
       end
 
-      def repo_id(content_name, env_label = nil, docker_repo_name = nil)
-        return if content_name.nil?
-        return content_name if content_name.include?(self.organization.label) && content_name.include?(self.label.to_s)
-        Repository.repo_id(self.label.to_s, content_name.to_s, env_label,
-                           self.organization.label, nil, nil, docker_repo_name)
-      end
-
       def repo_url(content_url)
         if self.provider.provider_type == Provider::CUSTOM
           content_url.dup
@@ -234,7 +227,6 @@ module Katello
                    end
         Repository.new(:environment => self.organization.library,
                        :product => self,
-                       :pulp_id => repo_id(label),
                        :relative_path => rel_path,
                        :arch => arch,
                        :name => name,