katello 3.6.0.1.rc2 → 3.7.0.rc1

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

@@ -0,0 +1,25 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Job < CandlepinResource
+        class << self
+          NOT_FINISHED_STATES = %w(CREATED PENDING RUNNING).freeze unless defined? NOT_FINISHED_STATES
+
+          def not_finished?(job)
+            NOT_FINISHED_STATES.include?(job[:state])
+          end
+
+          def get(id, params = {})
+            job_json = super(path(id) + hash_to_query(params), self.default_headers).body
+            job = JSON.parse(job_json)
+            job.with_indifferent_access
+          end
+
+          def path(id = nil)
+            "/candlepin/jobs/#{id}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Owner < CandlepinResource
+        extend OwnerResource
+
+        class << self
+          # 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"}
+            owner_json = self.post(path, attrs.to_json, self.default_headers).body
+            JSON.parse(owner_json).with_indifferent_access
+          end
+
+          # create the first user for owner
+          def create_user(_key, username, password)
+            # create user with superadmin flag (no role, permissions etc)
+            CPUser.create(:username => name_to_key(username), :password => name_to_key(password), :superAdmin => true)
+          end
+
+          def destroy(key)
+            self.delete(path(key), User.cp_oauth_header).code.to_i
+          end
+
+          def find(key)
+            owner_json = self.get(path(key), {'accept' => 'application/json'}.merge(User.cp_oauth_header)).body
+            JSON.parse(owner_json).with_indifferent_access
+          end
+
+          def update(key, attrs)
+            owner = find(key)
+            owner.merge!(attrs)
+            self.put(path(key), JSON.generate(owner), self.default_headers).body
+          end
+
+          def import(organization_name, path_to_file, options)
+            path = join_path(path(organization_name), 'imports')
+            if options[:force] || SETTINGS[:katello].key?(:force_manifest_import)
+              path += "?force=#{SETTINGS[:katello][:force_manifest_import]}"
+            end
+
+            self.post(path, {:import => File.new(path_to_file, 'rb')}, self.default_headers.except('content-type'))
+          end
+
+          def product_content(organization_name)
+            Product.all(organization_name, [:id, :productContent])
+          end
+
+          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'
+              while !response['state'].nil? && response['state'] != 'FINISHED' && response['state'] != 'ERROR'
+                path = join_path('candlepin', response['statusPath'][1..-1])
+                response_json = self.get(path, self.default_headers)
+                response = JSON.parse(response_json).with_indifferent_access
+              end
+            end
+
+            response
+          end
+
+          def imports(organization_name)
+            imports_json = self.get(join_path(path(organization_name), 'imports'), self.default_headers)
+            ::Katello::Util::Data.array_with_indifferent_access JSON.parse(imports_json)
+          end
+
+          def pools(owner_label, filter = {})
+            filter[:add_future] ||= true
+            params = hash_to_query(filter)
+            if owner_label
+              # hash_to_query escapes the ":!" to "%3A%21" which candlepin rejects
+              params += '&attribute=unmapped_guests_only:!true'
+              json_str = self.get(join_path(path(owner_label), 'pools') + params, self.default_headers).body
+            else
+              json_str = self.get(join_path('candlepin', 'pools') + params, self.default_headers).body
+            end
+            ::Katello::Util::Data.array_with_indifferent_access JSON.parse(json_str)
+          end
+
+          def statistics(key)
+            json_str = self.get(join_path(path(key), 'statistics'), self.default_headers).body
+            ::Katello::Util::Data.array_with_indifferent_access JSON.parse(json_str)
+          end
+
+          def generate_ueber_cert(key)
+            ueber_cert_json = self.post(join_path(path(key), "uebercert"), {}.to_json, self.default_headers).body
+            JSON.parse(ueber_cert_json).with_indifferent_access
+          end
+
+          def get_ueber_cert(key)
+            ueber_cert_json = self.get(join_path(path(key), "uebercert"), {'accept' => 'application/json'}.merge(User.cp_oauth_header)).body
+            JSON.parse(ueber_cert_json).with_indifferent_access
+          end
+
+          def get_ueber_cert_pkcs12(key, name = nil, password = nil)
+            certs = get_ueber_cert(key)
+            c = OpenSSL::X509::Certificate.new certs["cert"]
+            p = OpenSSL::PKey::RSA.new certs["key"]
+            OpenSSL::PKCS12.create(password, name, p, c, nil, "PBE-SHA1-3DES", "PBE-SHA1-3DES")
+          end
+
+          def events(key)
+            response = self.get(join_path(path(key), 'events'), self.default_headers).body
+            ::Katello::Util::Data.array_with_indifferent_access JSON.parse(response)
+          end
+
+          def service_levels(uuid)
+            response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'servicelevels'), self.default_headers).body
+            if response.empty?
+              return []
+            else
+              JSON.parse(response)
+            end
+          end
+
+          def auto_attach(key)
+            response = self.post(join_path(path(key), 'entitlements'), "", self.default_headers).body
+            if response.empty?
+              return nil
+            else
+              JSON.parse(response)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Katello
+  module Resources
+    module Candlepin
+      class OwnerInfo < CandlepinResource
+        class << self
+          def find(key)
+            owner_json = self.get(path(key), {'accept' => 'application/json'}.merge(User.cp_oauth_header)).body
+            JSON.parse(owner_json).with_indifferent_access
+          end
+
+          def path(id = nil)
+            "/candlepin/owners/#{id}/info"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Pool < CandlepinResource
+        extend PoolResource
+
+        class << self
+          def get_for_owner(owner_key, include_temporary_guests = false)
+            url = "#{prefix}/owners/#{owner_key}/pools?add_future=true"
+            url += "&attribute=unmapped_guests_only:!true" if include_temporary_guests
+            pools_json = self.get(url, self.default_headers).body
+            JSON.parse(pools_json)
+          end
+
+          def create(owner_key, attrs)
+            pool = self.post("/candlepin/owners/#{owner_key}/pools", attrs.to_json, self.default_headers).body
+            pool
+          end
+
+          def find(pool_id)
+            pool_json = self.get(path(pool_id), self.default_headers).body
+            fail ArgumentError, "pool id cannot contain ?" if pool_id["?"]
+            JSON.parse(pool_json).with_indifferent_access
+          end
+
+          def destroy(id)
+            fail ArgumentError, "pool id has to be specified" unless id
+            self.delete(path(id), self.default_headers).code.to_i
+          end
+
+          def entitlements(pool_id, included = [])
+            entitlement_json = self.get("#{path(pool_id)}/entitlements?#{included_list(included)}", self.default_headers).body
+            JSON.parse(entitlement_json)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Product < CandlepinResource
+        class << self
+          def all(owner_label, included = [])
+            JSON.parse(Candlepin::CandlepinResource.get(path(owner_label) + "?#{included_list(included)}", self.default_headers).body)
+          end
+
+          def find_for_stacking_id(owner_key, stacking_id)
+            Subscription.get_for_owner(owner_key).each do |subscription|
+              if subscription['product']['attributes'].any? { |attr| attr['name'] == 'stacking_id' && attr['value'] == stacking_id }
+                return subscription['product']
+              end
+            end
+            nil
+          end
+
+          def create(owner_label, attr)
+            JSON.parse(self.post(path(owner_label), attr.to_json, self.default_headers).body).with_indifferent_access
+          end
+
+          def get(owner_label, id = nil, included = [])
+            products_json = super(path(owner_label, id + "/?#{included_list(included)}"), self.default_headers).body
+            products = JSON.parse(products_json)
+            products = [products] unless id.nil?
+            ::Katello::Util::Data.array_with_indifferent_access products
+          end
+
+          def product_certificate(id, owner)
+            included = %w(certificate product.id providedProducts.id
+                          derivedProvidedProducts.id startDate)
+            subscriptions_json = Candlepin::CandlepinResource.get(
+              "/candlepin/owners/#{owner}/subscriptions?#{included_list(included)}",
+              self.default_headers
+            ).body
+            subscriptions = JSON.parse(subscriptions_json)
+
+            product_subscription = subscriptions.find do |sub|
+              sub['certificate'] && Time.parse(sub['startDate']) < Time.now &&
+              (sub["product"]["id"] == id ||
+                sub["providedProducts"].any? { |provided| provided["id"] == id } ||
+                sub["derivedProvidedProducts"].any? { |provided| provided["id"] == id })
+            end
+
+            if product_subscription
+              return product_subscription["certificate"]
+            end
+          end
+
+          def certificate(id, owner)
+            self.product_certificate(id, owner).try :[], 'cert'
+          end
+
+          def key(id, owner)
+            self.product_certificate(id, owner).try :[], 'key'
+          end
+
+          def destroy(owner_label, product_id)
+            fail ArgumentError, "product id has to be specified" unless product_id
+            self.delete(path(owner_label, product_id), self.default_headers).code.to_i
+          end
+
+          def add_content(owner_label, product_id, content_id, enabled)
+            self.post(join_path(path(owner_label, product_id), "content/#{content_id}?enabled=#{enabled}"), nil, self.default_headers).code.to_i
+          end
+
+          def remove_content(owner_label, product_id, content_id)
+            self.delete(join_path(path(owner_label, product_id), "content/#{content_id}"), self.default_headers).code.to_i
+          end
+
+          def create_unlimited_subscription(owner_key, product_id, start_date)
+            start_date ||= Time.now
+            # End it 100 years from now
+            end_date ||= start_date + 10_950.days
+
+            pool = {
+              'startDate' => start_date,
+              'endDate'   => end_date,
+              'quantity'  =>  -1,
+              'accountNumber' => '',
+              'productId' => product_id,
+              'providedProducts' => [],
+              'contractNumber' => ''
+            }
+            JSON.parse(Candlepin::Pool.create(owner_key, pool))
+          end
+
+          def pools(owner_key, product_id)
+            Candlepin::Pool.get_for_owner(owner_key).find_all { |pool| pool['productId'] == product_id }
+          end
+
+          def delete_subscriptions(owner_key, product_id)
+            update_subscriptions = false
+            subscriptions = Candlepin::Subscription.get_for_owner owner_key
+            subscriptions.each do |s|
+              products = ([s['product']] + s['providedProducts'])
+              products.each do |p|
+                if p['id'] == product_id
+                  logger.debug "Deleting subscription: " + s.to_json
+                  Candlepin::Subscription.destroy s['id']
+                  update_subscriptions = true
+                end
+              end
+            end
+            nil
+          end
+
+          def path(owner_label, id = nil)
+            "/candlepin/owners/#{owner_label}/products/#{id}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Proxy
+        def self.logger
+          ::Foreman::Logging.logger('katello/cp_proxy')
+        end
+
+        def self.post(path, body)
+          logger.debug "Sending POST request to Candlepin: #{path}"
+          client = CandlepinResource.rest_client(Net::HTTP::Post, :post, path_with_cp_prefix(path))
+          client.post body, {:accept => :json, :content_type => :json}.merge(User.cp_oauth_header)
+        end
+
+        def self.delete(path, body = nil)
+          logger.debug "Sending DELETE request to Candlepin: #{path}"
+          client = CandlepinResource.rest_client(Net::HTTP::Delete, :delete, path_with_cp_prefix(path))
+          # Some candlepin calls will set the body in DELETE requests.
+          client.options[:payload] = body unless body.nil?
+          client.delete({:accept => :json, :content_type => :json}.merge(User.cp_oauth_header))
+        end
+
+        def self.get(path)
+          logger.debug "Sending GET request to Candlepin: #{path}"
+          client = CandlepinResource.rest_client(Net::HTTP::Get, :get, path_with_cp_prefix(path))
+          client.get({:accept => :json}.merge(User.cp_oauth_header))
+        end
+
+        def self.put(path, body)
+          logger.debug "Sending PUT request to Candlepin: #{path}"
+          client = CandlepinResource.rest_client(Net::HTTP::Put, :put, path_with_cp_prefix(path))
+          client.put body, {:accept => :json, :content_type => :json}.merge(User.cp_oauth_header)
+        end
+
+        def self.path_with_cp_prefix(path)
+          CandlepinResource.prefix + path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Katello
+  module Resources
+    module Candlepin
+      class Subscription < CandlepinResource
+        class << self
+          def destroy(subscription_id)
+            fail ArgumentError, "subscription id has to be specified" unless subscription_id
+            self.delete(path(subscription_id), self.default_headers).code.to_i
+          end
+
+          def get(id = nil)
+            content_json = super(path(id), self.default_headers).body
+            JSON.parse(content_json)
+          end
+
+          def get_for_owner(owner_key, included = [])
+            content_json = Candlepin::CandlepinResource.get(
+              "/candlepin/owners/#{owner_key}/subscriptions?#{included_list(included)}",
+              self.default_headers
+            ).body
+            JSON.parse(content_json)
+          end
+
+          def path(id = nil)
+            "/candlepin/subscriptions/#{id}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Katello
+  module Resources
+    module Candlepin
+      class UpstreamConsumer < UpstreamCandlepinResource
+        extend ConsumerResource
+
+        class << self
+          def path(id = upstream_consumer_id)
+            super(id)
+          end
+
+          def remove_entitlement(entitlement_id)
+            fail ArgumentError, "No entitlement ID given to remove." if entitlement_id.blank?
+
+            self["entitlements/#{entitlement_id}"].delete
+          end
+
+          def 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
+          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,
+                                                                       'accept' => 'application/json',
+                                                                       'accept-language' => I18n.locale,
+                                                                       'content-type' => 'application/json')
+          end
+
+          def bind_entitlement(**pool)
+            JSON.parse(self['entitlements'].post(nil, params: pool))
+          end
+        end
+      end
+    end
+  end
+end