katello 3.14.1 → 3.15.0.rc1

data/app/services/katello/pulp3/api/ansible_collection.rb

@@ -0,0 +1,46 @@
+require "pulpcore_client"
+# rubocop:disable ClassLength
+
+module Katello
+  module Pulp3
+    module Api
+      class AnsibleCollection < Core
+        def self.api_exception_class
+          PulpAnsibleClient::ApiError
+        end
+
+        def self.client_module
+          PulpAnsibleClient
+        end
+
+        def self.remote_class
+          PulpAnsibleClient::AnsibleCollectionRemote
+        end
+
+        def self.distribution_class
+          PulpAnsibleClient::AnsibleAnsibleDistribution
+        end
+
+        def api_client
+          PulpAnsibleClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpAnsibleClient::Configuration))
+        end
+
+        def repositories_api
+          PulpAnsibleClient::RepositoriesAnsibleApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpAnsibleClient::RepositoriesAnsibleVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpAnsibleClient::RemotesCollectionApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpAnsibleClient::DistributionsAnsibleApi.new(api_client)
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/api/core.rb

@@ -0,0 +1,159 @@
+require "pulpcore_client"
+# rubocop:disable ClassLength
+
+module Katello
+  module Pulp3
+    module Api
+      class Core
+        attr_accessor :smart_proxy
+
+        def initialize(smart_proxy)
+          @smart_proxy = smart_proxy
+        end
+
+        def self.api_exception_class
+          fail NotImplementedError
+        end
+
+        def self.client_module
+          fail NotImplementedError
+        end
+
+        def self.remote_class
+          fail NotImplementedError
+        end
+
+        def self.distribution_class
+          fail NotImplementedError
+        end
+
+        def self.publication_class
+          fail NotImplementedError
+        end
+
+        def api_client
+          fail NotImplementedError
+        end
+
+        def remotes_api
+          fail NotImplementedError
+        end
+
+        def publications_api
+          fail NotImplementedError #Optional
+        end
+
+        def distributions_api
+          fail NotImplementedError
+        end
+
+        def repositories_api
+          fail NotImplementedError
+        end
+
+        def repository_versions_api
+          fail NotImplementedError
+        end
+
+        def orphans_api
+          PulpcoreClient::OrphansApi.new(core_api_client)
+        end
+
+        def core_api_client
+          PulpcoreClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpcoreClient::Configuration))
+        end
+
+        def uploads_api
+          PulpcoreClient::UploadsApi.new(core_api_client)
+        end
+
+        def tasks_api
+          PulpcoreClient::TasksApi.new(core_api_client)
+        end
+
+        def upload_class
+          PulpcoreClient::Upload
+        end
+
+        def delete_orphans
+          [orphans_api.delete]
+        end
+
+        def delete_remote(remote_href)
+          remotes_api.delete(remote_href)
+        end
+
+        def repository_versions(options = {})
+          current_pulp_repositories = self.list_all(options)
+          repo_hrefs = current_pulp_repositories.collect { |repo| repo.pulp_href }.uniq
+
+          version_hrefs = repo_hrefs.collect do |href|
+            versions_list_for_repository(href, options).map(&:pulp_href)
+          end
+
+          version_hrefs.flatten.uniq
+        end
+
+        def versions_list_for_repository(repository_href, options)
+          self.class.fetch_from_list { |page_opts| repository_versions_api.list(repository_href, page_opts.merge(options)) }
+        end
+
+        def distributions_list_all(args = {})
+          self.class.fetch_from_list do |page_opts|
+            distributions_api.list(page_opts.merge(args))
+          end
+        end
+
+        def get_distribution(href)
+          distributions_api.read(href)
+        rescue self.class.api_exception_class => e
+          raise e if e.code != 404
+          nil
+        end
+
+        def delete_distribution(href)
+          distributions_api.delete(href)
+        rescue self.class.api_exception_class => e
+          raise e if e.code != 404
+          nil
+        end
+
+        def list_all(options = {})
+          self.class.fetch_from_list do |page_opts|
+            repositories_api.list(page_opts.merge(options))
+          end
+        end
+
+        def remotes_list(args = {})
+          remotes_api.list(args).results
+        end
+
+        def remotes_list_all(_smart_proxy, options)
+          self.class.fetch_from_list do |page_opts|
+            remotes_api.list(page_opts.merge(options))
+          end
+        end
+
+        def self.fetch_from_list
+          page_size = SETTINGS[:katello][:pulp][:bulk_load_size]
+          page_opts = { "offset" => 0, limit: page_size }
+          response = {}
+
+          results = []
+
+          loop do
+            page_opts = page_opts.with_indifferent_access
+            break unless (
+            (response.count && (page_opts['offset'] < response.count)) ||
+                page_opts["offset"] == 0)
+            response = yield page_opts
+            results = results.concat(response.results)
+            page_opts[:offset] += page_size
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/api/docker.rb

@@ -0,0 +1,62 @@
+require "pulpcore_client"
+# rubocop:disable ClassLength
+
+module Katello
+  module Pulp3
+    module Api
+      class Docker < Core
+        def self.api_exception_class
+          PulpContainerClient::ApiError
+        end
+
+        def self.client_module
+          PulpContainerClient
+        end
+
+        def self.remote_class
+          PulpContainerClient::ContainerContainerRemote
+        end
+
+        def self.distribution_class
+          PulpContainerClient::ContainerContainerDistribution
+        end
+
+        def self.publication_class
+          PulpContainerClient::ContainerPublication
+        end
+
+        def self.recursive_manage_class
+          PulpContainerClient::RecursiveManage
+        end
+
+        def api_client
+          PulpContainerClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpContainerClient::Configuration))
+        end
+
+        def repositories_api
+          PulpContainerClient::RepositoriesContainerApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpContainerClient::RepositoriesContainerVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpContainerClient::RemotesContainerApi.new(api_client)
+        end
+
+        def publications_api
+          PulpContainerClient::PublicationsContainerApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpContainerClient::DistributionsContainerApi.new(api_client)
+        end
+
+        def recursive_add_api
+          PulpContainerClient::ContainerRecursiveAddApi.new(api_client)
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/api/file.rb

@@ -0,0 +1,54 @@
+require "pulpcore_client"
+# rubocop:disable ClassLength
+
+module Katello
+  module Pulp3
+    module Api
+      class File < Core
+        def self.api_exception_class
+          PulpFileClient::ApiError
+        end
+
+        def self.client_module
+          PulpFileClient
+        end
+
+        def self.remote_class
+          PulpFileClient::FileFileRemote
+        end
+
+        def self.distribution_class
+          PulpFileClient::FileFileDistribution
+        end
+
+        def self.publication_class
+          PulpFileClient::FileFilePublication
+        end
+
+        def api_client
+          PulpFileClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpFileClient::Configuration))
+        end
+
+        def repositories_api
+          PulpFileClient::RepositoriesFileApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpFileClient::RepositoriesFileVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpFileClient::RemotesFileApi.new(api_client)
+        end
+
+        def publications_api
+          PulpFileClient::PublicationsFileApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpFileClient::DistributionsFileApi.new(api_client)
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/api/yum.rb

@@ -0,0 +1,54 @@
+require "pulpcore_client"
+# rubocop:disable ClassLength
+
+module Katello
+  module Pulp3
+    module Api
+      class Yum < Core
+        def self.api_exception_class
+          PulpRpmClient::ApiError
+        end
+
+        def self.client_module
+          PulpRpmClient
+        end
+
+        def self.remote_class
+          PulpRpmClient::RpmRpmRemote
+        end
+
+        def self.distribution_class
+          PulpRpmClient::RpmRpmDistribution
+        end
+
+        def self.publication_class
+          PulpRpmClient::RpmRpmPublication
+        end
+
+        def api_client
+          PulpRpmClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpRpmClient::Configuration))
+        end
+
+        def repositories_api
+          PulpRpmClient::RepositoriesRpmApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpRpmClient::RepositoriesRpmVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpRpmClient::RemotesRpmApi.new(api_client)
+        end
+
+        def publications_api
+          PulpRpmClient::PublicationsRpmApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpRpmClient::DistributionsRpmApi.new(api_client)
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/distribution.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Pulp3
+    class Distribution < PulpContentUnit
+      include LazyAccessor
+
+      def self.content_api
+        PulpRpmClient::ContentDistributionTreesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/docker_blob.rb

@@ -4,7 +4,7 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpDockerClient::ContentBlobsApi.new(Katello::Pulp3::Repository::Docker.api_client(SmartProxy.pulp_master!))
+        PulpContainerClient::ContentBlobsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
       end
 
       def self.ids_for_repository(repo_id)

data/app/services/katello/pulp3/docker_manifest.rb

@@ -4,7 +4,7 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpDockerClient::ContentManifestsApi.new(Katello::Pulp3::Repository::Docker.api_client(SmartProxy.pulp_master!))
+        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
       end
 
       def self.ids_for_repository(repo_id)

data/app/services/katello/pulp3/docker_manifest_list.rb

@@ -4,7 +4,7 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpDockerClient::ContentManifestsApi.new(Katello::Pulp3::Repository::Docker.api_client(SmartProxy.pulp_master!))
+        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
       end
 
       def self.ids_for_repository(repo_id)

data/app/services/katello/pulp3/docker_tag.rb

@@ -4,7 +4,7 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpDockerClient::ContentTagsApi.new(Katello::Pulp3::Repository::Docker.api_client(SmartProxy.pulp_master!))
+        PulpContainerClient::ContentTagsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
       end
 
       def self.ids_for_repository(repo_id)

data/app/services/katello/pulp3/erratum.rb

@@ -0,0 +1,109 @@
+module Katello
+  module Pulp3
+    class Erratum < PulpContentUnit
+      include LazyAccessor
+
+      def self.content_api
+        PulpRpmClient::ContentAdvisoriesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+
+      def update_model(model)
+        keys = %w(title id severity issued type description reboot_suggested solution updated summary)
+        custom_json = backend_data.slice(*keys)
+
+        # handle SUSE epoch dates
+        custom_json["issued"] = convert_date_if_epoch(custom_json["issued"])
+        custom_json["updated"] = convert_date_if_epoch(custom_json["updated"]) unless custom_json["updated"].blank?
+
+        if model.updated.blank? || (custom_json['updated'].to_datetime != model.updated.to_datetime)
+          custom_json['errata_id'] = custom_json.delete('id')
+          custom_json['errata_type'] = custom_json.delete('type')
+          custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated']
+          model.update_attributes!(custom_json)
+
+          unless backend_data['references'].blank?
+            update_bugzillas(model, backend_data['references'])
+            update_cves(model, backend_data['references'])
+          end
+        end
+        update_packages(model, backend_data['pkglist']) unless backend_data['pkglist'].blank?
+        update_modules(model, backend_data['pkglist']) unless backend_data['pkglist'].blank?
+      end
+
+      def update_bugzillas(model, ref_list)
+        ref_list.select { |r| r[:type] == "bugzilla" }.each do |bugzilla|
+          Katello::Util::Support.active_record_retry do
+            model.bugzillas.where(bug_id: bugzilla[:id]).first_or_create!(bug_id: bugzilla[:id], href: bugzilla[:href], erratum_id: model.id)
+          end
+        end
+      end
+
+      def update_cves(model, ref_list)
+        ref_list.select { |r| r[:type] == "cve" }.each do |cve|
+          Katello::Util::Support.active_record_retry do
+            model.cves.where(cve_id: cve[:id]).first_or_create!(cve_id: cve[:id], href: cve[:href], erratum_id: model.id)
+          end
+        end
+      end
+
+      def update_packages(model, package_list)
+        package_list.each do |json|
+          package_hashes = json[:packages]
+          package_attributes = package_hashes.map do |hash|
+            nvrea = Util::Package.build_nvra(hash)
+            {'name' => hash[:name], 'nvrea' => nvrea, 'filename' => hash[:filename]}
+          end
+          existing_nvreas = model.packages.pluck(:nvrea)
+          package_attributes.delete_if { |pkg| existing_nvreas.include?(pkg['nvrea']) }
+          package_attributes.uniq.each do |package|
+            Katello::Util::Support.active_record_retry do
+              model.packages.where(filename: package["filename"]).first_or_create!(package)
+            end
+          end
+        end
+      end
+
+      def update_modules(model, module_stream_list)
+        module_stream_attributes = []
+        module_stream_list.each do |package_item|
+          if package_item[:module]
+            module_stream = ::Katello::ModuleStream.where(package_item[:module]).first
+            next if module_stream.blank?
+            nvreas = package_item[:packages].map { |hash| Util::Package.build_nvra(hash) }
+            module_stream_id_column = "#{ModuleStreamErratumPackage.table_name}.module_stream_id"
+            existing = ErratumPackage.joins(:module_streams).
+                                      where(module_stream_id_column => module_stream.id,
+                                            :nvrea => nvreas).pluck(:nvrea)
+
+            (nvreas - existing).each do |nvrea|
+              package = model.packages.find_by(:nvrea => nvrea)
+              module_stream_attributes << { :module_stream_id => module_stream.id,
+                                            :erratum_package_id => package.id }
+            end
+          end
+        end
+        module_stream_attributes.uniq.each do |module_stream|
+          Katello::Util::Support.active_record_retry do
+            if model.module_streams.empty? || !model.module_streams.pluck(:module_stream_id).include?(module_stream[:module_stream_id])
+              ModuleStreamErratumPackage.create!(module_stream)
+            end
+          end
+        end
+      end
+
+      def convert_date_if_epoch(date)
+        date.to_i.to_s == date ? epoch_to_date(date) : date
+      end
+
+      def epoch_to_date(epoch)
+        Time.at(epoch.to_i).to_s
+      end
+    end
+  end
+end