katello 4.0.3 → 4.1.0.rc1

data/app/models/katello/content_view.rb

@@ -10,6 +10,7 @@ module Katello
 
     CONTENT_DIR = "content_views".freeze
     IMPORT_LIBRARY = "Import-Library".freeze
+    EXPORT_LIBRARY = "Export-Library".freeze
 
     belongs_to :organization, :inverse_of => :content_views, :class_name => "::Organization"
 
@@ -36,10 +37,6 @@ module Katello
     has_many :repositories, :through => :content_view_repositories, :class_name => "Katello::Repository",
                             :after_remove => :remove_repository
 
-    has_many :content_view_puppet_modules, :class_name => "Katello::ContentViewPuppetModule",
-                                           :dependent => :destroy
-    alias_method :puppet_modules, :content_view_puppet_modules
-
     has_many :filters, :dependent => :destroy, :class_name => "Katello::ContentViewFilter"
 
     has_many :activation_keys, :class_name => "Katello::ActivationKey", :dependent => :restrict_with_exception
@@ -62,7 +59,6 @@ module Katello
     validates :name, :presence => true, :uniqueness => {:scope => :organization_id}
     validates :organization_id, :presence => true
     validate :check_non_composite_components
-    validate :check_puppet_conflicts
     validate :check_docker_conflicts
     validate :check_non_composite_auto_publish
     validates :composite, :inclusion => [true, false]
@@ -119,6 +115,10 @@ module Katello
       name == IMPORT_LIBRARY
     end
 
+    def library_export?
+      name.start_with? EXPORT_LIBRARY
+    end
+
     def content_host_count
       hosts.count
     end
@@ -197,18 +197,11 @@ module Katello
 
       copy_components(new_view)
 
-      self.content_view_puppet_modules.each do |puppet_module|
-        new_view.content_view_puppet_modules << puppet_module.dup
-      end
       copy_filters(new_view)
       new_view.save!
       new_view
     end
 
-    def publish_puppet_environment?
-      force_puppet_environment? || puppet_modules.any? || component_modules_to_publish.present?
-    end
-
     def promoted?
       # if the view exists in more than 1 environment, it has been promoted
       self.environments.many?
@@ -243,12 +236,6 @@ module Katello
       Katello::Deb.in_repositories(self.repos(env)).count
     end
 
-    def total_puppet_module_count(env)
-      repoids = self.repos(env).collect { |r| r.pulp_id }
-      result = Katello::PuppetModule.legacy_search('*', :page_size => 1, :repoids => repoids)
-      result.length > 0 ? result.total : 0
-    end
-
     def in_environment?(env)
       environments.include?(env)
     end
@@ -265,10 +252,22 @@ module Katello
       latest_version_object.try(:version)
     end
 
+    def latest_version_id
+      latest_version_object.try(:id)
+    end
+
+    def latest_version_env
+      latest_version_object.try(:environments) || []
+    end
+
     def latest_version_object
       self.versions.order('major DESC').order('minor DESC').first
     end
 
+    def last_task
+      history.order(:created_at).last
+    end
+
     def history
       Katello::ContentViewHistory.joins(:content_view_version).where(
           "#{Katello::ContentViewVersion.table_name}.content_view_id" => self.id)
@@ -284,11 +283,6 @@ module Katello
       (self.repositories.collect { |r| r.product }).uniq
     end
 
-    def puppet_repos
-      # These are the repos that may contain puppet modules that can be associated with the content view
-      self.organization.library.repositories.puppet_type
-    end
-
     def repos(env = nil)
       if env
         repo_ids = versions.flat_map { |version| version.repositories.in_environment(env) }.map(&:id)
@@ -298,15 +292,6 @@ module Katello
       Repository.where(:id => repo_ids)
     end
 
-    def puppet_env(env)
-      if env
-        ids = versions.flat_map { |version| version.content_view_puppet_environments.in_environment(env) }.map(&:id)
-      else
-        ids = []
-      end
-      ContentViewPuppetEnvironment.where(:id => ids).first
-    end
-
     def library_repos
       Repository.where(:id => library_repo_ids)
     end
@@ -380,18 +365,6 @@ module Katello
       end
     end
 
-    # Returns actual puppet modules associated with all components
-    def component_modules_to_publish
-      composite? ? components.flat_map { |version| version.puppet_modules } : nil
-    end
-
-    # Returns the content view puppet modules associated with the content view
-    #
-    # @returns array of ContentViewPuppetModule
-    def puppet_modules_to_publish
-      composite? ? nil : content_view_puppet_modules
-    end
-
     def component_repositories
       components.map(&:archived_repos).flatten
     end
@@ -459,14 +432,6 @@ module Katello
       Repository.where(:id => ids)
     end
 
-    def duplicate_puppet_modules
-      modules = puppet_modules_to_publish || component_modules_to_publish
-      counts = modules.each_with_object(Hash.new(0)) do |puppet_module, h|
-        h[puppet_module.name] += 1
-      end
-      counts.select { |_k, v| v > 1 }.keys
-    end
-
     def duplicate_docker_repos
       duplicate_repositories.docker_type
     end
@@ -483,15 +448,6 @@ module Katello
       end
     end
 
-    def check_puppet_conflicts
-      duplicate_puppet_modules.each do |name|
-        versions = components.select { |v| v.puppet_modules.map(&:name).include?(name) }
-        names = versions.map(&:name).join(", ")
-        msg = _("Puppet module conflict: '%{mod}' is in %{versions}.") % {mod: name, versions: names}
-        errors.add(:base, msg)
-      end
-    end
-
     def check_docker_conflicts
       duplicate_docker_repos.each do |repo|
         msg = _("Container Image repo '%{repo}' is present in multiple component content views.") % {repo: repo.name}
@@ -556,58 +512,6 @@ module Katello
       version
     end
 
-    def build_puppet_env(options)
-      if options[:environment] && options[:version]
-        fail "Cannot create into both an environment and a content view version archive"
-      end
-
-      to_env       = options[:environment]
-      version      = options[:version]
-      content_view = self
-      to_version   = version || content_view.version(to_env)
-
-      ContentViewPuppetEnvironment.new(
-        :environment => to_env,
-        :content_view_version => to_version,
-        :name => self.name
-      )
-    end
-
-    def create_puppet_env(options)
-      build_puppet_env(options).save!
-    end
-
-    def computed_modules_by_repoid
-      names_and_authors = []
-      puppet_modules = []
-
-      if composite?
-        puppet_modules = component_modules_to_publish
-      else
-        puppet_modules_to_publish.each do |cvpm|
-          if cvpm.uuid
-            puppet_modules << cvpm.puppet_module
-          else
-            names_and_authors << { :name => cvpm.name, :author => cvpm.author }
-          end
-        end
-      end
-
-      if names_and_authors.present?
-        names_and_authors.each do |name_and_author|
-          puppet_module = ::Katello::PuppetModule.latest_module(
-            name_and_author[:name],
-            name_and_author[:author],
-            self.organization.library.repositories.puppet_type
-          )
-          puppet_modules << puppet_module if puppet_module
-        end
-      end
-
-      # In order to minimize the number of copy requests, organize the data by repoid.
-      PuppetModule.group_by_repoid(puppet_modules.flatten)
-    end
-
     def check_ready_to_import!
       fail _("Cannot import a composite content view") if composite?
       fail _("This Content View must be set to Import-only before performing an import") unless import_only?

data/app/models/katello/content_view_component.rb

@@ -18,6 +18,11 @@ module Katello
 
     before_validation :update_content_view, :on => :create
 
+    scoped_search :on => :name, :relation => :content_view, :complete_value => true
+    scoped_search :on => :organization_id, :relation => :content_view, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :label, :relation => :content_view, :complete_value => true
+    scoped_search :on => :composite, :relation => :content_view, :complete_value => true
+
     def latest_version
       if latest?
         self.content_view.latest_version_object

data/app/models/katello/content_view_docker_filter_rule.rb

@@ -1,6 +1,7 @@
 module Katello
   class ContentViewDockerFilterRule < Katello::Model
     include ::Katello::Concerns::ContentViewFilterRuleCommon
+    include ScopedSearchExtensions
     belongs_to :filter,
                :class_name => "Katello::ContentViewDockerFilter",
                :inverse_of => :docker_rules,

data/app/models/katello/content_view_package_filter_rule.rb

@@ -10,6 +10,10 @@ module Katello
     validates :name, :presence => true
     validate :ensure_unique_attributes
     validates_with Validators::ContentViewFilterVersionValidator
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :min_version, :complete_value => true
+    scoped_search :on => :max_version, :complete_value => true
+    scoped_search :on => :architecture, :complete_value => true
 
     def ensure_unique_attributes
       other = self.class.where(:name => self.name,

data/app/models/katello/content_view_package_group_filter.rb

@@ -4,6 +4,7 @@ module Katello
 
     has_many :package_group_rules, :dependent => :destroy, :foreign_key => :content_view_filter_id,
                                    :class_name => "Katello::ContentViewPackageGroupFilterRule"
+
     validates_lengths_from_database
 
     def generate_clauses(_repo)

data/app/models/katello/content_view_repository.rb

@@ -4,12 +4,11 @@ module Katello
                                 Repository::DOCKER_TYPE,
                                 Repository::OSTREE_TYPE,
                                 Repository::FILE_TYPE,
-                                Repository::DEB_TYPE
+                                Repository::DEB_TYPE,
+                                Repository::ANSIBLE_COLLECTION_TYPE
                                ].freeze
 
-    ALLOWED_IMPORT_REPOSITORY_TYPES = [
-      Repository::YUM_TYPE
-    ].freeze
+    ALLOWED_IMPORT_REPOSITORY_TYPES = Repository::EXPORTABLE_TYPES
 
     belongs_to :content_view, :inverse_of => :content_view_repositories,
                               :class_name => "Katello::ContentView"
@@ -17,7 +16,7 @@ module Katello
                             :class_name => "Katello::Repository"
 
     validates_lengths_from_database
-    validates :repository_id, :uniqueness => {:scope => :content_view_id}
+    validates :repository_id, :uniqueness => {:scope => :content_view_id, :message => N_("already belongs to the content view") }
     validate :content_view_composite
     validate :ensure_repository_type
     validate :check_repo_membership

data/app/models/katello/content_view_version.rb

@@ -1,5 +1,4 @@
 module Katello
-  # rubocop:disable Metrics/ClassLength
   class ContentViewVersion < Katello::Model
     include Authorization::ContentViewVersion
     include ForemanTasks::Concerns::ActionSubject
@@ -23,12 +22,11 @@ module Katello
     has_many :triggered_histories, :class_name => "Katello::ContentViewHistory", :dependent => :destroy,
              :inverse_of => :triggered_by, :foreign_key => :triggered_by_id
 
-    has_many :export_histories, :class_name => "Katello::ContentViewVersionExportHistory", :dependent => :destroy,
+    has_many :export_histories, :class_name => "::Katello::ContentViewVersionExportHistory", :dependent => :destroy,
+             :inverse_of => :content_view_version, :foreign_key => :content_view_version_id
+    has_many :import_histories, :class_name => "::Katello::ContentViewVersionImportHistory", :dependent => :destroy,
              :inverse_of => :content_view_version, :foreign_key => :content_view_version_id
-
     has_many :repositories, :class_name => "::Katello::Repository", :dependent => :destroy
-    has_many :content_view_puppet_environments, :class_name => "Katello::ContentViewPuppetEnvironment",
-                                                :dependent => :destroy
     has_one :task_status, :class_name => "Katello::TaskStatus", :as => :task_owner, :dependent => :destroy
 
     has_many :content_view_components, :class_name => "Katello::ContentViewComponent",
@@ -100,11 +98,6 @@ module Katello
       query
     end
 
-    def self.with_puppet_module(puppet_module)
-      joins(:content_view_puppet_environments)
-        .where("#{Katello::ContentViewPuppetEnvironment.table_name}.id" => puppet_module.content_view_puppet_environments)
-    end
-
     def to_s
       name
     end
@@ -119,6 +112,10 @@ module Katello
       self.history.order(:created_at).last
     end
 
+    def env_promote_date(env)
+      Katello::ContentViewEnvironment.where(:environment_id => env.id, :content_view_version_id => self.id).pluck(:updated_at).try(:first)
+    end
+
     def name
       "#{content_view} #{version}"
     end
@@ -159,14 +156,6 @@ module Katello
       self.repositories.in_environment(env)
     end
 
-    def puppet_env(env)
-      self.content_view_puppet_environments.in_environment(env).first
-    end
-
-    def promote_puppet_environment?
-      (!content_counts.blank? && content_counts.dig(PuppetModule::CONTENT_TYPE) > 0) || self.content_view.force_puppet_environment?
-    end
-
     def archived_repos
       self.default? ? self.repositories : self.repos(nil)
     end
@@ -226,18 +215,6 @@ module Katello
       end
     end
 
-    def archive_puppet_environment
-      content_view_puppet_environments.archived.first
-    end
-
-    def puppet_modules
-      if archive_puppet_environment
-        archive_puppet_environment.puppet_modules
-      else
-        []
-      end
-    end
-
     def components_needing_errata(errata)
       component_repos = Repository.where(:content_view_version_id => self.components)
       library_repos = Repository.where(:id => component_repos.pluck(:library_instance_id)).with_errata(errata)
@@ -317,7 +294,6 @@ module Katello
           content_counts[content_type::CONTENT_TYPE] = content_type.in_repositories(self.repositories.archived).count
         end
       end
-      self.content_counts[PuppetModule::CONTENT_TYPE] = self.puppet_modules.count
       save!
     end
 
@@ -361,9 +337,9 @@ module Katello
 
     def importable_repositories
       if default?
-        repositories.yum_type
+        repositories.exportable
       else
-        archived_repos.yum_type
+        archived_repos.exportable
       end
     end
 

data/app/models/katello/content_view_version_export_history.rb

@@ -1,12 +1,15 @@
 module Katello
   class ContentViewVersionExportHistory < Katello::Model
     include Authorization::ContentViewVersionExportHistory
+    audited except: :metadata
+    delegate :organization, to: :content_view_version
+    delegate :id, to: :organization, prefix: true
 
     COMPLETE = "complete".freeze
     INCREMENTAL = "incremental".freeze
     EXPORT_TYPES = [COMPLETE, INCREMENTAL].freeze
 
-    belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion", :inverse_of => :export_histories
+    belongs_to :content_view_version, :class_name => "::Katello::ContentViewVersion", :inverse_of => :export_histories, foreign_key: 'content_view_version_id'
     validates_lengths_from_database
 
     validates :content_view_version_id, :presence => true
@@ -19,7 +22,7 @@ module Katello
     validates :metadata, :presence => true
     serialize :metadata, Hash
 
-    before_validation :set_export_type, :if => -> { export_type.blank? }
+    before_validation :set_export_type
 
     scope :with_organization_id, ->(organization_id) do
       where(:content_view_version_id => ContentViewVersion.with_organization_id(organization_id))
@@ -39,12 +42,23 @@ module Katello
             destination_server: destination_server).order(:created_at).last
     end
 
-    def export_type_from_metadata
+    def self.export_type_from_metadata(metadata)
       metadata[:incremental] ? INCREMENTAL : COMPLETE
     end
 
     def set_export_type
-      self.export_type = export_type_from_metadata
+      self.export_type ||= self.class.export_type_from_metadata(metadata)
+    end
+
+    def self.generate_audit_comment(user:, content_view_version:, from_version: nil, metadata:)
+      export_type = export_type_from_metadata(metadata)
+      if content_view_version.content_view.library_export?
+        export_descriptor = "library export"
+      else
+        export_descriptor = "export of content view '#{content_view_version.content_view.name}' version #{content_view_version.version}"
+        export_descriptor += " from #{from_version.name}" if from_version
+      end
+      "#{export_type&.capitalize} #{export_descriptor} created by #{user.to_label}"
     end
   end
 end

data/app/models/katello/content_view_version_import_history.rb

@@ -0,0 +1,42 @@
+module Katello
+  class ContentViewVersionImportHistory < Katello::Model
+    include Authorization::ContentViewVersionImportHistory
+
+    audited except: :metadata
+    delegate :organization, to: :content_view_version
+    delegate :id, to: :organization, prefix: true
+
+    belongs_to :content_view_version, :class_name => "::Katello::ContentViewVersion", :inverse_of => :import_histories
+    validates_lengths_from_database
+
+    validates :content_view_version_id, presence: true
+    validates :metadata, presence: true
+    validates :path, presence: true
+    serialize :metadata, Hash
+
+    before_validation do |history|
+      history.import_type = ContentViewVersionExportHistory.export_type_from_metadata(history.metadata)
+    end
+
+    scope :with_organization_id, ->(organization_id) do
+      where(:content_view_version_id => ContentViewVersion.with_organization_id(organization_id))
+    end
+
+    scope :with_content_view_id, ->(cv_id) do
+      where(:content_view_version_id => ContentViewVersion.where(content_view_id: cv_id))
+    end
+
+    scoped_search :on => :content_view_id, :relation => :content_view_version, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
+    scoped_search :on => :content_view_version_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :import_type, :rename => :type, :complete_value => ContentViewVersionExportHistory::EXPORT_TYPES
+
+    def self.generate_audit_comment(user:, path:, content_view_name:)
+      _("Content imported from %{path} into content view '%{name}' by %{user}") % {
+        path: path,
+        user: user.to_label,
+        name: content_view_name
+      }
+    end
+  end
+end

data/app/models/katello/erratum.rb

@@ -19,7 +19,7 @@ module Katello
 
     scoped_search :on => :errata_id, :only_explicit => true
     scoped_search :on => :errata_id, :rename => :id, :complete_value => true, :only_explicit => true
-    scoped_search :on => :title, :only_explicit => true
+    scoped_search :on => :title
     scoped_search :on => :severity, :complete_value => true
     scoped_search :on => :errata_type, :only_explicit => true
     scoped_search :on => :errata_type, :rename => :type, :complete_value => true

data/app/models/katello/events/delete_pool.rb

@@ -0,0 +1,19 @@
+module Katello
+  module Events
+    class DeletePool
+      EVENT_TYPE = 'delete_pool'.freeze
+
+      def initialize(pool_id)
+        @pool_id = pool_id
+      end
+
+      def run
+        if ::Katello::Pool.where(id: @pool_id).destroy_all.any?
+          Rails.logger.info("Deleted pool #{@pool_id}")
+        else
+          Rails.logger.info("Pool with id=#{@pool_id} has already been removed")
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,13 @@ module Katello
         Resources::Candlepin::Environment.find(self.cp_id)
       end
 
+      def exists_in_candlepin?
+        candlepin_info
+        true
+      rescue RestClient::NotFound
+        false
+      end
+
       def content_ids
         self.candlepin_info['environmentContent'].collect { |c| c['id'] }
       end

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

@@ -16,8 +16,19 @@ module Katello
     end
 
     module InstanceMethods
+      def find_owner
+        Resources::Candlepin::Owner.find(self.label)
+      end
+
+      def candlepin_owner_exists?
+        find_owner
+        true
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
       def owner_details
-        @owner_details ||= Resources::Candlepin::Owner.find self.label
+        @owner_details ||= find_owner
         @owner_details['virt_who'] ||= self.subscriptions.using_virt_who.any?
 
         @owner_details

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

@@ -10,7 +10,7 @@ module Katello
         lazy_accessor :subscription_facts, :initializer => lambda { |_s| self.subscription ? self.subscription.attributes : {} }
 
         lazy_accessor :pool_derived, :owner, :source_pool_id, :virt_limit, :arch, :description, :product_family,
-          :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id, :role, :usage, :addons,
+          :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id, :roles, :usage, :addons,
           :initializer => :pool_facts
 
         lazy_accessor :name, :support_level, :org, :sockets, :cores, :instance_multiplier,
@@ -27,8 +27,16 @@ module Katello
     end
 
     module ClassMethods
-      def candlepin_data(cp_id)
+      def candlepin_data(cp_id, rescue_gone = false)
         Katello::Resources::Candlepin::Pool.find(cp_id)
+      rescue Katello::Errors::CandlepinPoolGone => e
+        raise e unless rescue_gone
+
+        if (pool_id = ::Katello::Pool.find_by_cp_id(cp_id)&.id)
+          Katello::EventQueue.push_event(::Katello::Events::DeletePool::EVENT_TYPE, pool_id)
+          Rails.logger.warn("Sending pool delete event for missing candlepin pool cp_id=#{cp_id}")
+        end
+        {}
       end
 
       def get_for_owner(organization)
@@ -36,19 +44,39 @@ module Katello
       end
 
       def import_pool(cp_pool_id, index_hosts = true)
-        json = candlepin_data(cp_pool_id)
-        ::Katello::Util::Support.active_record_retry do
-          pool = Katello::Pool.where(:cp_id => cp_pool_id, :organization => Organization.find_by(:label => json['owner']['key'])).first_or_create
-          pool.backend_data = json
-          pool.import_data(index_hosts)
+        Katello::Logging.time("import candlepin pool", data: { cp_id: cp_pool_id }) do
+          json = candlepin_data(cp_pool_id)
+
+          org = Organization.find_by(label: json['owner']['key'])
+          fail("Organization with label #{json['owner']['key']} wasn't found while importing Candlepin pool") unless org
+
+          subscription = determine_subscription(
+            product_id: json['productId'],
+            source_stack_id: json['sourceStackId'],
+            organization: org
+          )
+
+          ::Katello::Util::Support.active_record_retry do
+            pool = Katello::Pool.where(cp_id: cp_pool_id, organization: org, subscription: subscription).first_or_create!
+            pool.backend_data = json
+            pool.import_data(index_hosts)
+          end
+        end
+      end
+
+      def determine_subscription(product_id: nil, source_stack_id: nil, organization:)
+        if source_stack_id
+          self.stacking_subscription(organization, source_stack_id)
+          # isn't it an error if we have a sourceStackID but no stacking subscription?
+        else
+          ::Katello::Subscription.find_by(:cp_id => product_id, organization: organization)
         end
       end
 
-      def stacking_subscription(org_label, stacking_id)
-        org = Organization.find_by(:label => org_label)
+      def stacking_subscription(org, stacking_id)
         subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => stacking_id)
         if subscription.nil?
-          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
+          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org.label, stacking_id)
           subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
         end
         subscription
@@ -57,7 +85,9 @@ module Katello
 
     module InstanceMethods
       def import_lazy_attributes
-        json = self.backend_data
+        json = self.class.candlepin_data(self.cp_id, true)
+
+        return {} if json.blank?
 
         pool_attributes = json["attributes"] + json["productAttributes"]
         json["virt_only"] = false
@@ -78,9 +108,7 @@ module Katello
         json["product_id"] = json["productId"] if json["productId"]
         json["upstream_entitlement_id"] = json["upstreamEntitlementId"]
 
-        if self.subscription
-          subscription.backend_data["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
-        end
+        subscription.backend_data["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
         json
       end
 
@@ -93,24 +121,13 @@ module Katello
 
       # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data
 
-        self.organization ||= Organization.find_by(:label => pool_json['owner']['key'])
         product_attributes = pool_json["productAttributes"] + pool_json["attributes"]
-
         product_attributes.map { |attr| pool_attributes[attr["name"].underscore.to_sym] = attr["value"] }
 
-        if pool_json["sourceStackId"]
-          subscription = Pool.stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
-        else
-          subscription = ::Katello::Subscription.find_by(:cp_id => pool_json["productId"])
-        end
-
-        pool_attributes[:subscription_id] = subscription.id if subscription
-
         %w(accountNumber contractNumber quantity startDate endDate accountNumber consumed).each do |json_attribute|
           pool_attributes[json_attribute.underscore] = pool_json[json_attribute]
         end