katello 4.3.0 → 4.4.0.rc1

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

@@ -1,7 +0,0 @@
-module Katello
-  module Pulp
-    class Distribution < PulpContentUnit
-      CONTENT_TYPE = "distribution".freeze
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module Katello
-  module Pulp
-    class DockerBlob < PulpContentUnit
-      CONTENT_TYPE = "docker_blob".freeze
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Katello
-  module Pulp
-    class DockerManifest < PulpContentUnit
-      CONTENT_TYPE = "docker_manifest".freeze
-
-      def update_model(model)
-        model.update(:schema_version => backend_data[:schema_version],
-                          :digest => backend_data[:digest]
-         )
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Katello
-  module Pulp
-    class DockerManifestList < PulpContentUnit
-      CONTENT_TYPE = "docker_manifest_list".freeze
-
-      def update_model(model)
-        model.update(:schema_version => backend_data[:schema_version],
-                          :digest => backend_data[:digest],
-                          :docker_manifests => ::Katello::DockerManifest.where(:digest => backend_data[:manifests].pluck(:digest))
-                         )
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Katello
-  module Pulp
-    class DockerTag < PulpContentUnit
-      CONTENT_TYPE = "docker_tag".freeze
-
-      def update_model(model)
-        taggable_class = backend_data['manifest_type'] == "list" ? ::Katello::DockerManifestList : ::Katello::DockerManifest
-        model.docker_taggable = taggable_class.find_by(:digest => backend_data['manifest_digest'])
-        model.name = backend_data['name']
-        model.save!
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-module Katello
-  module Pulp
-    class Erratum < PulpContentUnit
-      PULP_SELECT_FIELDS = %w(errata_id).freeze
-      CONTENT_TYPE = "erratum".freeze
-
-      def self.unit_handler
-        Katello.pulp_server.extensions.errata
-      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!(custom_json)
-
-          unless backend_data['references'].blank?
-            update_bugzillas(model, backend_data['references'].select { |r| r['type'] == 'bugzilla' })
-            update_cves(model, backend_data['references'].select { |r| r['type'] == 'cve' })
-          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, json)
-        needed_function = lambda do
-          existing_names = model.bugzillas.pluck(:bug_id)
-          json.select { |bz| !existing_names.include?(bz['id']) }
-        end
-        action_function = lambda do |needed|
-          model.bugzillas.create!(needed.map { |bug| {:bug_id => bug['id'], :href => bug['href']} })
-        end
-        run_until(model, needed_function, action_function)
-      end
-
-      def update_cves(model, json)
-        needed_function = lambda do
-          existing_names = model.cves.pluck(:cve_id)
-          json.select { |cve| !existing_names.include?(cve['id']) }
-        end
-        action_function = lambda do |needed|
-          model.cves.create!(needed.map { |cve| {:cve_id => cve['id'], :href => cve['href']} })
-        end
-        run_until(model, needed_function, action_function)
-      end
-
-      def update_packages(model, json)
-        needed_function = lambda do
-          package_hashes = json.map { |list| list['packages'] }.flatten
-          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 { |pkg| pkg['nvrea'] }
-        end
-        action_function = lambda do |needed|
-          model.packages.create!(needed)
-        end
-        run_until(model, needed_function, action_function)
-      end
-
-      def update_modules(model, json)
-        needed_function = lambda do
-          module_stream_attributes = []
-          json.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
-        end
-
-        action_function = lambda do |needed|
-          needed.each do |msep|
-            ModuleStreamErratumPackage.create!(msep)
-          end
-        end
-
-        run_until(model, needed_function, action_function)
-      end
-
-      def run_until(model, needed_function, action_function)
-        needed = needed_function.call
-        retries = needed.length
-        until needed.empty? || retries == 0
-          begin
-            action_function.call(needed)
-          rescue ActiveRecord::RecordNotUnique
-            model.reload
-          end
-          needed = needed_function.call
-          retries -= 1
-        end
-        fail _('Failed indexing errata, maximum retries encountered') if retries == 0 && needed.any?
-      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

data/app/services/katello/pulp/file_unit.rb

@@ -1,21 +0,0 @@
-module Katello
-  module Pulp
-    class FileUnit < PulpContentUnit
-      include LazyAccessor
-
-      PULP_SELECT_FIELDS = %w(name checksum).freeze
-      PULP_INDEXED_FIELDS = %w(name checksum).freeze
-      CONTENT_TYPE = "iso".freeze
-
-      lazy_accessor :pulp_facts, :initializer => :backend_data
-
-      def update_model(model)
-        custom_json = {}
-        custom_json['checksum'] = backend_data['checksum']
-        custom_json['path'] = backend_data['name']
-        custom_json['name'] = File.basename(backend_data['name'])
-        model.update!(custom_json)
-      end
-    end
-  end
-end

data/app/services/katello/pulp/module_stream.rb

@@ -1,39 +0,0 @@
-module Katello
-  module Pulp
-    class ModuleStream < PulpContentUnit
-      include LazyAccessor
-
-      CONTENT_TYPE = "modulemd".freeze
-
-      def update_model(model)
-        shared_attributes = backend_data.keys & model.class.column_names
-        shared_json = backend_data.select { |key, _v| shared_attributes.include?(key) }
-        model.update!(shared_json)
-
-        create_stream_artifacts(model, backend_data['artifacts']) if backend_data.key?('artifacts')
-        create_profiles(model, backend_data['profiles']) if backend_data.key?('profiles')
-      end
-
-      def create_stream_artifacts(model, artifacts_json)
-        artifacts_json.each do |name|
-          Katello::Util::Support.active_record_retry do
-            model.artifacts.where(name: name).first_or_create!
-          end
-        end
-      end
-
-      def create_profiles(model, profiles_json)
-        profiles_json.each do |profile, rpms|
-          Katello::Util::Support.active_record_retry do
-            profile = model.profiles.where(name: profile).first_or_create!
-          end
-          rpms.each do |rpm|
-            Katello::Util::Support.active_record_retry do
-              profile.rpms.where(name: rpm).first_or_create!
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/services/katello/pulp/package_category.rb

@@ -1,7 +0,0 @@
-module Katello
-  module Pulp
-    class PackageCategory < PulpContentUnit
-      CONTENT_TYPE = "package_category".freeze
-    end
-  end
-end

data/app/services/katello/pulp/package_group.rb

@@ -1,20 +0,0 @@
-module Katello
-  module Pulp
-    class PackageGroup < PulpContentUnit
-      include LazyAccessor
-
-      CONTENT_TYPE = 'package_group'.freeze
-
-      lazy_accessor :pulp_facts, :initializer => :backend_data
-
-      lazy_accessor :optional_package_names, :mandatory_package_names,
-                    :conditional_package_names, :default_package_names, :_id,
-                    :repository_memberships,
-                    :initializer => :pulp_facts
-
-      def update_model(model)
-        model.update!(backend_data.slice('name', 'description'))
-      end
-    end
-  end
-end

data/app/services/katello/pulp/pulp_content_unit.rb

@@ -1,156 +0,0 @@
-require 'set'
-
-module Katello
-  module Pulp
-    class PulpContentUnit
-      # Any class that extends this class should define:
-      # Class::CONTENT_TYPE
-      # Class#update_model
-
-      # Any class that extends this class can define:
-      # Class.unit_handler (optional)
-      # Class::PULP_INDEXED_FIELDS (optional)
-
-      attr_accessor :uuid
-      attr_writer :backend_data
-
-      def initialize(uuid)
-        self.uuid = uuid
-      end
-
-      def self.pulp_data(uuid)
-        unit_handler.find_by_unit_id(uuid)
-      end
-
-      def self.model_class
-        Katello::RepositoryTypeManager.model_class(self)
-      end
-
-      def self.unit_identifier
-        "_id"
-      end
-
-      def self.backend_unit_identifier
-        nil
-      end
-
-      def self.supports_id_fetch?
-        true
-      end
-
-      def self.content_type
-        self::CONTENT_TYPE
-      end
-
-      def self.unit_handler
-        Katello.pulp_server.extensions.send(self.name.demodulize.underscore)
-      end
-
-      def self.pulp_units_batch_all(unit_ids = nil, page_size = Setting[:bulk_load_size])
-        fields = self.const_get(:PULP_INDEXED_FIELDS) if self.constants.include?(:PULP_INDEXED_FIELDS)
-        criteria = {:limit => page_size, :skip => 0}
-        criteria[:fields] = fields if fields
-        criteria[:filters] = {'_id' => {'$in' => unit_ids}} if unit_ids
-
-        pulp_units_batch(criteria, page_size) do
-          Katello.pulp_server.resources.unit.search(self::CONTENT_TYPE, criteria, :include_repos => true)
-        end
-      end
-
-      def self.pulp_units_batch_for_repo(repository, options = {})
-        page_size = options.fetch(:page_size, Setting[:bulk_load_size])
-
-        fields = self.const_get(:PULP_INDEXED_FIELDS) if self.constants.include?(:PULP_INDEXED_FIELDS)
-        criteria = {:type_ids => [const_get(:CONTENT_TYPE)], :limit => page_size, :skip => 0}
-        criteria[:fields] = {:unit => fields} if fields
-
-        pulp_units_batch(criteria, page_size) do
-          Katello.pulp_server.resources.repository.unit_search(repository.pulp_id, criteria).pluck(:metadata)
-        end
-      end
-
-      def self.pulp_units_batch(criteria, page_size = Setting[:bulk_load_size], &block)
-        response = {}
-        Enumerator.new do |yielder|
-          loop do
-            break if (response.blank? && criteria[:skip] != 0)
-            response = block.call
-            yielder.yield response
-            criteria[:skip] += page_size
-          end
-        end
-      end
-
-      def self.fetch_all
-        count = 0
-        results = []
-        sub_list = fetch(0, Setting[:bulk_load_size])
-
-        until sub_list.empty? #we can't know how many there are, so we have to keep looping until we get nothing
-          count += sub_list.count
-          if block_given?
-            value = yield(sub_list)
-            value.is_a?(Array) ? results.concat(value) : results << value
-          else
-            results.concat(sub_list)
-          end
-
-          sub_list = fetch(count, Setting[:bulk_load_size])
-        end
-        results
-      end
-
-      def self.fetch_by_uuids(uuids)
-        results = []
-        uuids.each_slice(Setting[:bulk_load_size]) do |sub_list|
-          fetched = fetch(0, sub_list.length, sub_list)
-          if block_given?
-            value = yield(fetched)
-            value.is_a?(Array) ? results.concat(value) : results << value
-          else
-            results.concat(fetched)
-          end
-        end
-        results
-      end
-
-      def self.ids_for_repository(repo_id)
-        criteria = {:type_ids => [const_get(:CONTENT_TYPE)],
-                    :fields => {:unit => [], :association => ['unit_id']}}
-        Katello.pulp_server.resources.repository.unit_search(repo_id, criteria).map { |i| i['unit_id'] }
-      end
-
-      def self.fetch_for_repository(repo_id)
-        ids = ids_for_repository(repo_id)
-        fetch(0, ids.count, ids)
-      end
-
-      def self.fetch(offset, page_size, uuids = nil)
-        fields = self.const_get(:PULP_INDEXED_FIELDS) if self.constants.include?(:PULP_INDEXED_FIELDS)
-        criteria = {:limit => page_size, :skip => offset}
-        criteria[:fields] = fields if fields
-        criteria[:filters] = {'_id' => {'$in' => uuids}} if uuids
-        Katello.pulp_server.resources.unit.search(self::CONTENT_TYPE, criteria, :include_repos => true)
-      end
-
-      def backend_data
-        @backend_data ||= fetch_backend_data
-        @backend_data.try(:with_indifferent_access)
-      end
-
-      def fetch_backend_data
-        self.class.pulp_data(self.uuid)
-      end
-
-      def self.remove(repo, uuids = nil)
-        fields = self.const_get(:PULP_SELECT_FIELDS) if self.constants.include?(:PULP_SELECT_FIELDS)
-        clauses = {:association => {'unit_id' => {'$in' => uuids}}}
-        clause = { type_ids: [const_get(:CONTENT_TYPE)]}
-        clause = clause.merge(filters: clauses) if uuids
-        clause = clause.merge(fields: { :unit => fields}) if fields
-        Katello.pulp_server.resources.repository.unassociate_units(repo.pulp_id,
-                                                                   clause)
-      end
-    end
-  end
-end

data/app/services/katello/pulp/rpm.rb

@@ -1,57 +0,0 @@
-module Katello
-  module Pulp
-    class Rpm < PulpContentUnit
-      include LazyAccessor
-
-      PULP_SELECT_FIELDS = %w(name epoch version release arch checksumtype checksum).freeze
-      PULP_INDEXED_FIELDS = %w(name version release arch epoch summary sourcerpm checksum filename is_modular).freeze
-      CONTENT_TYPE = "rpm".freeze
-
-      lazy_accessor :description, :license, :buildhost, :vendor, :relativepath, :children, :checksumtype,
-                    :changelog, :group, :size, :url, :build_time, :group,
-                    :initializer => :backend_data
-
-      def requires
-        if backend_data['requires']
-          backend_data['requires'].map { |entry| Katello::Util::Package.format_requires(entry) }.uniq.sort
-        else
-          []
-        end
-      end
-
-      def provides
-        if backend_data['provides']
-          backend_data['provides'].map { |entry| Katello::Util::Package.build_nvrea(entry, false) }.uniq.sort
-        else
-          []
-        end
-      end
-
-      def files
-        result = []
-        if backend_data['files']
-          if backend_data['files']['file']
-            result << backend_data['files']['file']
-          end
-          if backend_data['files']['dir']
-            result << backend_data['files']['dir']
-          end
-        end
-        result.flatten
-      end
-
-      def update_model(model)
-        keys = PULP_INDEXED_FIELDS - ['_id', 'is_modular']
-        data = backend_data.slice(*keys)
-        data['modular'] = backend_data['is_modular'] == true
-        if data.any? { |name, value| model.send(name) != value }
-          data[:release_sortable] = Util::Package.sortable_version(data[:release])
-          data[:version_sortable] = Util::Package.sortable_version(data[:version])
-          model.assign_attributes(data)
-          model.nvra = model.build_nvra
-          model.save!
-        end
-      end
-    end
-  end
-end

data/app/services/katello/pulp/srpm.rb

@@ -1,29 +0,0 @@
-module Katello
-  module Pulp
-    class Srpm < PulpContentUnit
-      include LazyAccessor
-
-      PULP_SELECT_FIELDS = %w(name epoch version release arch checksumtype checksum).freeze
-      PULP_INDEXED_FIELDS = %w(name version release arch epoch summary checksum filename).freeze
-      CONTENT_TYPE = "srpm".freeze
-
-      lazy_accessor :pulp_facts, :initializer => :backend_data
-
-      lazy_accessor :description, :license, :buildhost, :vendor, :relativepath, :children, :checksumtype,
-                    :changelog, :group, :size, :url, :build_time, :group,
-                    :initializer => :pulp_facts
-
-      def update_model(model)
-        keys = Pulp::Srpm::PULP_INDEXED_FIELDS - ['_id']
-        custom_json = backend_data.slice(*keys)
-        if custom_json.any? { |name, value| model.send(name) != value }
-          custom_json[:release_sortable] = Util::Package.sortable_version(custom_json[:release])
-          custom_json[:version_sortable] = Util::Package.sortable_version(custom_json[:version])
-          model.assign_attributes(custom_json)
-          model.nvra = model.build_nvra
-          model.save!
-        end
-      end
-    end
-  end
-end

data/app/services/katello/pulp/yum_metadata_file.rb

@@ -1,30 +0,0 @@
-module Katello
-  module Pulp
-    class YumMetadataFile < PulpContentUnit
-      CONTENT_TYPE = "yum_repo_metadata_file".freeze
-
-      def update_model(model)
-        shared_attributes = backend_data.keys & model.class.column_names
-        shared_json = backend_data.select { |key, _v| shared_attributes.include?(key) }
-        repo = ::Katello::Repository.find_by(:pulp_id => backend_data['repo_id']).try(:id)
-        filename = find_name_from_json(backend_data)
-        model.update!(shared_json.merge(repository_id: repo, name: filename))
-        if repo
-          Katello::YumMetadataFile.where("id != ? AND repository_id = ? AND name = ? AND checksum = ?",
-                                         model.id, repo, filename, model.checksum).delete_all
-        end
-      end
-
-      def find_name_from_json(json)
-        # get the name of the metadata file.
-        # Notice that pulp does not have a way to get name of the metadata file
-        # so we infer it from the _storage_path
-        # for example from the following storage path
-        #  "/var/lib/pulp/content/units/yum_repo_metadata_file/..../050-productid.gz"
-        # we find the right most '/' and return everything after that
-        # i.e ->  "050-productid.gz"
-        File.basename(json["_storage_path"])
-      end
-    end
-  end
-end

data/lib/monkeys/pulp3_13_checksumfix.rb

@@ -1,17 +0,0 @@
-require 'pulp_rpm_client'
-
-unless PulpRpmClient.const_defined?('OneOfMetadataChecksumTypeEnumNullEnum')
-  class PulpRpmClient::OneOfMetadataChecksumTypeEnumNullEnum
-    def self.build_from_hash(value)
-      value
-    end
-  end
-end
-
-unless PulpRpmClient.const_defined?('OneOfPackageChecksumTypeEnumNullEnum')
-  class PulpRpmClient::OneOfPackageChecksumTypeEnumNullEnum
-    def self.build_from_hash(value)
-      value
-    end
-  end
-end

data/webpack/__mocks__/foremanReact/components/Pagination/PaginationHooks.js

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import/prefer-default-export
-export const usePaginationOptions = () => [5, 10, 20, 50];

data/webpack/__mocks__/foremanReact/components/Pagination/PaginationWrapper.js

@@ -1,2 +0,0 @@
-const PaginationWrapper = () => jest.fn();
-export default PaginationWrapper;