katello 2.2.2 → 2.4.0.rc1

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

@@ -1,15 +1,3 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Katello
   module Glue::Candlepin::Consumer
     SYSTEM = "system"
@@ -24,18 +12,21 @@ module Katello
       base.send :extend, ClassMethods
 
       base.class_eval do
-        as_json_hook :consumer_as_json
-
-        attr_accessible :cp_type, :owner, :serviceLevel, :installedProducts, :facts, :guestIds, :releaseVer, :autoheal
+        attr_accessible :cp_type, :owner, :serviceLevel, :installedProducts, :facts, :guestIds, :releaseVer, :autoheal,
+                        :lastCheckin
 
-        lazy_accessor :href, :facts, :cp_type, :href, :idCert, :owner, :lastCheckin, :created, :guestIds,
+        lazy_accessor :href, :facts, :cp_type, :idCert, :owner, :lastCheckin, :created, :guestIds,
         :installedProducts, :autoheal, :releaseVer, :serviceLevel, :capabilities, :entitlementStatus,
-        :initializer => (lambda do |_s|
-                           if uuid
-                             consumer_json = Resources::Candlepin::Consumer.get(uuid)
-                             convert_from_cp_fields(consumer_json)
-                           end
-                         end)
+        :initializer => :candlepin_consumer_info
+
+        lazy_accessor :candlepin_consumer_info, :initializer =>
+                        (lambda do |_s|
+                          if uuid
+                            consumer_json = Resources::Candlepin::Consumer.get(uuid)
+                            convert_from_cp_fields(consumer_json)
+                          end
+                        end)
+
         lazy_accessor :entitlements, :initializer => lambda { |_s| Resources::Candlepin::Consumer.entitlements(uuid) }
         lazy_accessor :pools, :initializer => lambda { |_s| entitlements.collect { |ent| Resources::Candlepin::Pool.find ent["pool"]["id"] } }
         lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(uuid, false) }
@@ -81,20 +72,6 @@ module Katello
         end
       end
 
-      def serializable_hash(options = {})
-        hash = super(options)
-        hash = hash.merge(:serviceLevel => self.serviceLevel)
-        hash
-      end
-
-      def consumer_as_json(json = {})
-        json['compliance'] = self.compliance
-        json['registered'] = self.created
-        json['checkin_time'] = self.checkin_time
-        json['distribution'] = self.distribution
-        json
-      end
-
       def load_from_cp(consumer_json)
         self.uuid = consumer_json[:uuid]
         consumer_json[:facts] ||= {'sockets' => 0}
@@ -127,6 +104,7 @@ module Katello
       end
 
       def subscribe(pool, quantity = nil)
+        quantity = quantity.to_i unless quantity.nil?
         Rails.logger.debug "Subscribing to pool '#{pool}' for : #{name}"
         Resources::Candlepin::Consumer.consume_entitlement self.uuid, pool, quantity
       rescue => e
@@ -244,9 +222,7 @@ module Katello
       end
 
       def virtual_guest
-        v = facts["virt.is_guest"]
-        return false if (v == false || v.nil?)
-        return(v == true || v.to_bool)
+        ::Foreman::Cast.to_bool(facts["virt.is_guest"])
       end
 
       def virtual_guest=(val)
@@ -378,17 +354,6 @@ module Katello
         avail_pools
       end
 
-      def consumed_entitlements
-        self.entitlements.collect do |entitlement|
-          pool = self.get_pool(entitlement['pool']['id'])
-          entitlement_pool = Katello::Pool.new(pool)
-          entitlement_pool.cp_id = entitlement['id']
-          entitlement_pool.subscription_id = entitlement['pool']['id']
-          entitlement_pool.amount = entitlement['quantity']
-          entitlement_pool
-        end
-      end
-
       def set_content_override(content_label, name, value = nil)
         Resources::Candlepin::Consumer.update_content_override(self.uuid, content_label, name, value)
       end
@@ -445,18 +410,20 @@ module Katello
         all_products = []
 
         self.entitlements.each do |entitlement|
-          pool = Katello::Pool.find_pool(entitlement['pool']['id'])
+          pool = Katello::Pool.find_by_cp_id(entitlement['pool']['id'])
           Katello::Product.where(:cp_id => pool.product_id).each do |product|
-            if product.is_a? Katello::MarketingProduct
-              all_products += product.engineering_products
-            else
-              all_products << product
-            end
+            all_products << product
           end
         end
 
         return all_products
       end
+
+      def find_entitlement(pool_id)
+        entitlements = self.entitlements.collect { |ent| ent['id'] if ent["pool"]["id"] == pool_id }
+        entitlements.compact!
+        entitlements.first
+      end
     end
 
     module ClassMethods

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

@@ -1,18 +1,6 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Katello
   module Glue::Candlepin::Content
-    CANDLEPIN_DOCKER_TYPE = "containerImage"
+    CANDLEPIN_DOCKER_TYPE = "containerimage"
 
     def self.included(base)
       base.send :include, InstanceMethods

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

@@ -1,15 +1,3 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 require 'set'
 
 module Katello

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

@@ -1,15 +1,3 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Katello
   module Glue::Candlepin::Owner
     def self.included(base)
@@ -19,7 +7,7 @@ module Katello
       base.class_eval do
         validates :label,
             :presence => true,
-            :format => { :with => /^[\w-]*$/ }
+            :format => { :with => /\A[\w-]*\z/ }
 
         lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Owner.events(label) }
         lazy_accessor :service_levels, :initializer => lambda { |_s| Resources::Candlepin::Owner.service_levels(label) }
@@ -28,13 +16,6 @@ module Katello
     end
 
     module InstanceMethods
-      def serializable_hash(options = {})
-        hash = super(options)
-        hash = hash.merge(:service_levels => self.service_levels)
-        hash = hash.merge(:service_level => self.service_level)
-        hash
-      end
-
       def owner_info
         Glue::Candlepin::OwnerInfo.new(self)
       end
@@ -53,11 +34,10 @@ module Katello
 
       def pools(consumer_uuid = nil)
         if consumer_uuid
-          pools = Resources::Candlepin::Owner.pools self.label, :consumer => consumer_uuid
+          Resources::Candlepin::Owner.pools self.label, :consumer => consumer_uuid
         else
-          pools = Resources::Candlepin::Owner.pools self.label
+          Resources::Candlepin::Owner.pools self.label
         end
-        pools.collect { |p| Katello::Pool.new p }
       end
 
       def generate_debug_cert

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

@@ -1,15 +1,3 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Katello
   class Glue::Candlepin::OwnerInfo
     def initialize(organization)

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

@@ -1,15 +1,3 @@
-#
-# Copyright 2014 Red Hat, Inc.
-#
-# This software is licensed to you under the GNU General Public
-# License as published by the Free Software Foundation; either version
-# 2 of the License (GPLv2) or (at your option) any later version.
-# There is NO WARRANTY for this software, express or implied,
-# including the implied warranties of MERCHANTABILITY,
-# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
-# have received a copy of GPLv2 along with this software; if not, see
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
-
 module Katello
   module Glue::Candlepin::Pool
     def self.included(base)
@@ -18,183 +6,124 @@ module Katello
       base.send :extend, ClassMethods
 
       base.class_eval do
-        lazy_accessor :remote_data, :pool_derived, :product_name, :consumed, :quantity, :available, :support_level, :support_type,
-          :start_date, :end_date, :attrs, :owner, :product_id, :account_number, :contract_number,
-          :source_pool_id, :host_id, :virt_only, :virt_limit, :multi_entitlement, :stacking_id,
-          :arch, :sockets, :cores, :ram, :description, :product_family, :variant, :provided_products,
-          :active, :instance_multiplier, :suggested_quantity, :unmapped_guest,
-          :initializer => (lambda do |_s|
-                             json = Resources::Candlepin::Pool.find(cp_id)
-                             # symbol "attributes" is reserved by Rails and cannot be used
-                             json['attrs'] = json['attributes']
-                             json
-                           end)
+        lazy_accessor :pool_facts, :initializer => lambda { |_s| self.import_lazy_attributes }
+        lazy_accessor :subscription_facts, :initializer => lambda { |_s| self.subscription ? self.subscription.attributes : {} }
+
+        lazy_accessor :pool_derived, :owner, :source_pool_id, :host_id, :virt_only, :virt_limit, :arch, :description,
+          :product_family, :variant, :suggested_quantity, :unmapped_guest, :support_type, :product_id, :type,
+          :initializer => :pool_facts
+
+        lazy_accessor :name, :support_level, :org, :sockets, :cores, :stacking_id, :instance_multiplier,
+          :initializer => :subscription_facts
+
+        lazy_accessor :active, :initializer => lambda { |_s| self.backend_data["activeSubscription"] }
+
+        lazy_accessor :available, :initializer => lambda { |_s| self.quantity_available }
       end
     end
 
     module ClassMethods
-      def find_by_organization_and_id(organization, pool_id)
-        pool = Katello::Pool.find_by_cp_id(pool_id.to_s) || Pool.new(Resources::Candlepin::Pool.find(pool_id))
-        if pool.organization == organization
-          return pool
-        end
-      end
-
-      def find_by_organization_and_id!(organization, pool_id)
-        subscription = find_by_organization_and_id(organization, pool_id)
-        fail ActiveRecord::RecordNotFound if subscription.nil?
-        subscription
+      def candlepin_data(cp_id)
+        Katello::Resources::Candlepin::Pool.find(cp_id)
       end
 
-      def find_by_id(pool_id)
-        Katello::Pool.find_by_cp_id(pool_id) || Pool.new(Resources::Candlepin::Pool.find(pool_id))
+      def get_for_owner(organization)
+        Katello::Resources::Candlepin::Pool.get_for_owner(organization)
       end
 
-      def find_by_id!(pool_id)
-        subscription = find_by_id(pool_id)
-        fail ActiveRecord::RecordNotFound if subscription.nil?
-        subscription
+      def import_pool(cp_pool_id)
+        pool = Katello::Pool.find_or_create_by_cp_id(cp_pool_id)
+        pool.import_data
       end
     end
 
     module InstanceMethods
-      def initialize(attrs = nil, options = {})
-        if !attrs.nil? && attrs.member?('id')
-          # initializing from candlepin json
-          load_remote_data(attrs)
-          super({:cp_id => attrs['id']}, options)
-        else
-          super
+      def import_lazy_attributes
+        json = {}
+        json = self.backend_data
+
+        pool_attributes = json["attributes"] + json["productAttributes"]
+        pool_attributes.each do |attr|
+          json[attr["name"]] = attr["value"]
+          case attr["name"]
+          when 'requires_host'
+            json["host_id"] = attr['value']
+          when 'virt_only'
+            json["virtual"] = json["virt_only"] = attr['value'] == 'true' ? true : false
+          when 'virt_limit'
+            json["virt_limit"] = attr['value'].to_i
+          when 'unmapped_guests_only'
+            json['unmapped_guest'] = attr['value'] == 'true' ? true : false
+          end
         end
-      end
 
-      def organization
-        Organization.find_by_label(self.owner["key"])
+        json["calculatedAttributes"].each do |key|
+          json["suggested_quantity"] = json["calculatedAttributes"]["suggested_quantity"].to_i if key == 'suggested_quantity'
+        end if json["calculatedAttributes"]
+
+        json["product_id"] = json["productId"] if json["productId"]
+
+        if self.subscription
+          subscription.backend_data["product"]["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
+        end
+        json
       end
 
-      # if defined +load_remote_data+ will be used by +lazy_accessors+
-      # to define instance variables
-      # TODO: break up method
-      # rubocop:disable MethodLength
-      # rubocop:disable CyclomaticComplexity
-      def load_remote_data(attrs)
-        @amount = attrs["amount"]
-        @remote_data = attrs
-        @product_name = attrs["productName"]
-        @start_date = Date.parse(attrs["startDate"]) if attrs["startDate"]
-        @end_date = Date.parse(attrs["endDate"]) if attrs["endDate"]
-        @consumed = attrs["consumed"]
-        @quantity = attrs["quantity"]
-        if attrs["quantity"].is_a?(Integer) && attrs["consumed"].is_a?(Integer)
-          @available = attrs["quantity"] - attrs["consumed"]
-        else
-          @available = 0
+      def provider?(organization)
+        providers = self.subscription.products.collect do |provider|
+          Katello::Provider.where(:id => provider.provider_id, :organization_id => organization.id).first
         end
-        @attrs = attrs["attributes"]
-        @owner = attrs["owner"]
-        @product_id = attrs["productId"]
-        @cp_id = attrs['id']
-        @account_number = attrs['accountNumber']
-        @contract_number = attrs['contractNumber']
-        @provided_products = attrs['providedProducts']
-        @active = attrs['activeSubscription']
-        @source_pool_id = nil
-        @host_id = nil
-        @virt_only = false
-        @pool_derived = false
-        @unmapped_guest = false
-        attrs['attributes'].each do |attr|
-          case attr['name']
-          when 'source_pool_id'
-            @source_pool_id = attr['value']
-          when 'requires_host'
-            @host_id = attr['value']
-          when 'virt_only'
-            @virt_only = attr['value'] == 'true' ? true : false
-          when 'pool_derived'
-            @pool_derived = attr['value'] == 'true' ? true : false
-          when 'unmapped_guests_only'
-            @unmapped_guest = attr['value'] == 'true' ? true : false
-          end
-        end if attrs['attributes']
-        @virt_limit = 0
-        @support_type = ""
-        @arch = ""
-        @support_level = ""
-        @sockets = 0
-        @ram = 0
-        @cores = 0
-        @description = ""
-        @product_family = ""
-        @variant = ""
-        @multi_entitlement = false
-        @stacking_id = ""
-        attrs['productAttributes'].each do |attr|
-          case attr['name']
-          when 'virt_limit'
-            @virt_limit = attr['value'].to_i
-          when 'support_type'
-            @support_type = attr['value']
-          when 'arch'
-            @arch = attr['value']
-          when 'support_level'
-            @support_level = attr['value']
-          when 'sockets'
-            @sockets = attr['value'].to_i
-          when 'cores'
-            @cores = attr['value'].to_i
-          when 'ram'
-            @ram = attr['value'].to_i
-          when 'description'
-            @description = attr['value']
-          when 'product_family'
-            @product_family = attr['value']
-          when 'variant'
-            @variant = attr['value']
-          when 'multi-entitlement'
-            @multi_entitlement = (attr['value'] == 'true' || attr['value'] == 'yes') ? true : false
-          when 'stacking_id'
-            @stacking_id = attr['value']
-          when 'instance_multiplier'
-            @instance_multiplier = attr['value'].to_i
-          end
-        end if attrs['productAttributes']
+        providers.any?
+      end
 
-        @suggested_quantity = 1
-        attrs['calculatedAttributes'].each_key do |key|
-          case key
-          when 'suggested_quantity'
-            @suggested_quantity = attrs['calculatedAttributes']['suggested_quantity'].to_i
-          end
-        end if attrs['calculatedAttributes']
+      def backend_data
+        self.class.candlepin_data(self.cp_id)
       end
 
-      def products
-        Katello::Product.where(:cp_id => provided_products.map { |prod| prod[:productId] })
+      def import_data
+        pool_attributes = {}
+        pool_json = self.backend_data
+        product_attributes = pool_json["productAttributes"] + pool_json["attributes"]
+
+        product_attributes.map { |attr| pool_attributes[attr["name"].underscore.to_sym] = attr["value"] }
+
+        subscription = ::Katello::Subscription.where(:cp_id => pool_json["subscriptionId"])
+        pool_attributes[:subscription_id] = subscription.first.id if subscription.any?
+
+        %w(accountNumber contractNumber quantity startDate endDate accountNumber consumed).each do |json_attribute|
+          pool_attributes[json_attribute.underscore] = pool_json[json_attribute]
+        end
+        pool_attributes[:pool_type] = pool_json["type"] if pool_json.key?("type")
+
+        if pool_attributes.key?(:multi_entitlement)
+          pool_attributes[:multi_entitlement] = pool_attributes[:multi_entitlement] == "yes" ? true : false
+        end
+        pool_attributes[:host_id] = pool_attributes["requiresHost"] if pool_attributes.key?("requiresHost")
+
+        exceptions = pool_attributes.keys.map(&:to_sym) - self.attribute_names.map(&:to_sym)
+        self.update_attributes(pool_attributes.except!(*exceptions))
+        self.save!
+        self.create_activation_key_associations
       end
 
       def systems
         System.all_by_pool(cp_id)
       end
 
-      def activation_keys
+      def create_activation_key_associations
         keys = Resources::Candlepin::ActivationKey.get(nil, "?include=id&include=pools.pool.id")
         activation_key_ids = keys.collect do |key|
           key['id'] if key['pools'].any? { |pool| pool['pool']['id'] == cp_id }
         end
-
-        return Katello::ActivationKey.where(:cp_id => activation_key_ids.compact)
-      end
-
-      def distributors
-        Distributor.all_by_pool(cp_id)
+        related_keys = ::Katello::ActivationKey.where(:cp_id => activation_key_ids.compact)
+        related_keys.each do |key|
+          Katello::PoolActivationKey.find_or_create_by_activation_key_id_and_pool_id(key.id, self.id)
+        end
       end
 
       def host
-        System.find_by_uuid(host_id) if host_id
+        System.find_by_uuid(self.host_id) if self.host_id
       end
-
-      attr_reader :amount
     end
   end
 end