katello 3.18.5 → 4.0.0.rc1

data/app/lib/katello/util/hostgroup_facets_helper.rb

@@ -1,126 +0,0 @@
-# Used exclusively by fix_hostgroup_facets.rake task
-module Katello
-  module Util
-    class HostgroupFacetsHelper
-      def initialize
-        @logger = Logger.new($stdout)
-      end
-
-      def interested_hostgroups
-        groups = ::Hostgroup.unscoped.where(
-                    id: Katello::Hostgroup::ContentFacet.
-                        where(content_source_id: nil,
-                              kickstart_repository_id: nil,
-                              content_view_id: nil,
-                              lifecycle_environment_id: nil).select(:hostgroup_id))
-        parents = groups.select { |group| group.parent.blank? }
-        children = groups.reject { |group| group.parent.blank? }
-        # we want the parents to get created before the children
-        # hence the order
-        parents + children
-      end
-
-      def pick_facet_values(hg)
-        # This call looks at the audit logs for a host group.
-        # Pries out information related to lce, ks, cv and content_source_id from the audit logs.
-        # The audit logs typically only contain updates.
-        # So if the user changed  just the content_view_id, then that is the only thing marked as audited_changes.
-        # Hence we need to go through all the audit logs until we have information on lce, ks, cv and cs.
-        # If there was only one audit log and that was during the creation of hostgroup
-        # the audited changes look like this
-        # ```ruby
-        # {
-        #  content_view_id: 10,
-        #  kickstart_repository_id: 1000
-        #  ......
-        # }
-        # ```
-        # However if you updated the hostgroup and set the kickstart_repository_id, or
-        # content_view_id then audited changes look like
-        # ```ruby
-        # {
-        #  content_view_id: [10, 11],
-        #  kickstart_repository_id: [1000, 1200]
-        #  ......
-        # }
-        # ```
-        # So the code says "if the attribute value is an array pick the last value else just keep the value as it is "
-
-        # Further along it is to be noted that `hostgroup.audits` returns the audits ordered by the version number in ascending order, so the latest audit will be `hostgroup.audits.last`
-
-        # We want to iterate though each audit from latest audit to start, and as soon as we find a  content_view_id key or kickstart_repository_id key or lifecycle environment_id key  or content_source_id key we want it to be set once.
-
-        # So if I had an audit history like
-        # ``` ruby
-        # {
-        #  content_view_id: 10,
-        #  kickstart_repository_id: 1000,
-        #  version:1
-        #  ......
-        # },
-        # {
-        #  content_view_id: [10, 11],
-        #  kickstart_repository_id: [1000, 1200],
-        #   version: 2
-        #  ......
-        # }
-        # ```
-
-        # The code would start at version 2, notice that cv_id and ks_repo were set there
-        # and keep them as the final.
-        # So when it goes to version 1 since cv_id and ks_repo are already set,
-        # it will ignore. It will finally
-        # return {content_view_id: 11, kickstart_repository_id: 1200}
-        facet_values = {}
-        hg.audits.reverse_each do |audit|
-          hg_changes = audit.audited_changes.slice("lifecycle_environment_id",
-                                                   "kickstart_repository_id",
-                                                   "content_view_id",
-                                                   "content_source_id")
-          facet_values = hg_changes.merge(facet_values)
-        end
-
-        values = facet_values.map do |k, v|
-          v = v[-1] if v.is_a? Array
-          [k, v]
-        end
-        values.to_h.with_indifferent_access
-      end
-
-      def main
-        bad_hgs = []
-        good_hgs = []
-
-        groups = interested_hostgroups.each do |hg|
-          facet = hg.content_facet
-          values = pick_facet_values(hg)
-          if !values.empty? && facet.update(values)
-            good_hgs << { hostgroup: hg, facet_values: values }
-          else
-            bad_hgs << { hostgroup: hg, facet_values: values }
-            facet.save(validate: false)
-          end
-        end
-
-        unless bad_hgs.empty?
-          @logger.warn "Some of the hostgroups reported a validation error. "\
-                        "The hostgroups have been updated. "\
-                        "Check via the Web UI."
-
-          bad_hgs.each do |bad_group|
-            @logger.warn "Hostgroup #{bad_group[:hostgroup]}"
-            @logger.warn "Facet Values #{bad_group[:facet_values]}"
-          end
-        end
-        unless good_hgs.empty?
-          @logger.info "Following hostgroups were succesfully updated."
-          good_hgs.each do |good_group|
-            @logger.info "Hostgroup #{good_group[:hostgroup]}"
-            @logger.info "Facet Values #{good_group[:facet_values]}"
-          end
-        end
-        @logger.info("#{groups.count} Hostgroup(s) were updated.")
-      end
-    end
-  end
-end

data/app/overrides/disable_turbolinks_on_proxies_index.rb

@@ -1,5 +0,0 @@
-Deface::Override.new(
-  :virtual_path => 'smart_proxies/index',
-  :name => 'disable_turbolinks_on_proxies_index',
-  :set_attributes => '.proxy-show',
-  :attributes => {'data-no-turbolink' => 'true'})

data/app/services/katello/event_daemon.rb

@@ -1,135 +0,0 @@
-module Katello
-  class EventDaemon
-    @services = {}
-    @cache = ActiveSupport::Cache::MemoryStore.new
-
-    class Monitor
-      def initialize(service_classes)
-        @service_classes = service_classes
-      end
-
-      def start
-        error = nil
-        status = nil
-        loop do
-          Rails.application.executor.wrap do
-            check_services(error, status)
-          end
-          sleep 15
-        end
-      end
-
-      def check_services(error, status)
-        @service_classes.each do |service_class|
-          status = service_class.status
-        rescue => error
-          Rails.logger.error("Error occurred while pinging #{service_class}")
-          Rails.logger.error(error.message)
-          Rails.logger.error(error.backtrace.join("\n"))
-        ensure
-          if error || !status&.dig(:running)
-            begin
-              service_class.close
-              service_class.run
-              service_class.status
-            rescue => error
-              Rails.logger.error("Error occurred while starting #{service_class}")
-              Rails.logger.error(error.message)
-              Rails.logger.error(error.backtrace.join("\n"))
-            ensure
-              error = nil
-            end
-          end
-        end
-      end
-    end
-
-    class << self
-      def initialize
-        FileUtils.touch(lock_file)
-      end
-
-      def settings
-        SETTINGS[:katello][:event_daemon]
-      end
-
-      def pid
-        return unless pid_file && File.exist?(pid_file)
-
-        File.open(pid_file) { |f| f.read.to_i }
-      end
-
-      def pid_file
-        pid_dir.join('katello_event_daemon.pid')
-      end
-
-      def pid_dir
-        Rails.root.join('tmp', 'pids')
-      end
-
-      def lock_file
-        Rails.root.join('tmp', 'katello_event_daemon.lock')
-      end
-
-      def write_pid_file
-        return unless pid_file
-
-        FileUtils.mkdir_p(pid_dir)
-        File.open(pid_file, 'w') { |f| f.puts Process.pid }
-      end
-
-      def stop
-        return unless pid == Process.pid
-        @monitor_thread.kill
-        @cache.clear
-        @services.values.each(&:close)
-        File.unlink(pid_file) if pid_file && File.exist?(pid_file)
-      end
-
-      def start
-        return unless runnable?
-
-        lockfile = File.open(lock_file, 'r')
-        begin
-          lockfile.flock(File::LOCK_EX)
-          return if started? # ensure it wasn't started while we waited for the lock
-
-          start_monitor_thread
-          write_pid_file
-
-          at_exit do
-            stop
-          end
-
-          Rails.logger.info("Katello event daemon started process=#{Process.pid}")
-        ensure
-          lockfile.flock(File::LOCK_UN)
-        end
-      end
-
-      def started?
-        Process.kill(0, pid)
-        true
-      rescue Errno::ESRCH, TypeError # process no longer exists or we had no PID cached
-        false
-      end
-
-      def start_monitor_thread
-        @monitor_thread = Thread.new do
-          Monitor.new(@services.values).start
-        end
-      end
-
-      def runnable?
-        # avoid accessing the disk on each request
-        @cache.fetch('katello_event_daemon_runnable', expires_in: 1.minute) do
-          !started? && settings[:enabled] && !::Foreman.in_rake? && !Rails.env.test?
-        end
-      end
-
-      def register_service(name, klass)
-        @services[name] = klass
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module Katello
-  module Pulp
-    class ContentCountsCalculator
-      def initialize(repos)
-        @repos = repos
-      end
-
-      # rubocop:disable Metrics/MethodLength
-      def calculate
-        counts = {
-          :apt_repositories => 0,
-          :deb_packages => 0,
-          :yum_repositories => 0,
-          :packages => 0,
-          :package_groups => 0,
-          :errata => 0,
-          :puppet_repositories => 0,
-          :puppet_modules => 0,
-          :docker_repositories => 0,
-          :docker_images => 0
-        }
-
-        @repos.each do |repo|
-          case
-          when repo_type?(repo, 'deb')
-            counts[:apt_repositories] += 1
-            counts[:deb_packages] += get_unit_count(repo, 'deb')
-          when repo_type?(repo, 'rpm')
-            counts[:yum_repositories] += 1
-            counts[:packages] += get_unit_count(repo, 'rpm')
-            counts[:package_groups] += get_unit_count(repo, 'package_group')
-            counts[:errata] += get_unit_count(repo, 'erratum')
-          when repo_type?(repo, 'docker')
-            counts[:docker_repositories] += 1
-            counts[:docker_images] += get_unit_count(repo, 'docker_image')
-          when repo_type?(repo, 'puppet')
-            counts[:puppet_repositories] += 1
-            counts[:puppet_modules] += get_unit_count(repo, 'puppet_module')
-          end
-        end
-
-        counts
-      end
-
-      protected
-
-      def repo_type?(repo, repo_type)
-        repo['notes'] && (repo['notes']['_repo-type'] == "#{repo_type}-repo")
-      end
-
-      def get_unit_count(repo, unit_type)
-        if repo['content_unit_counts']
-          repo['content_unit_counts'][unit_type] || 0
-        else
-          0
-        end
-      end
-    end
-  end
-end

data/db/migrate/20210201165835_add_migration_missing_content.rb

@@ -1,12 +0,0 @@
-class AddMigrationMissingContent < ActiveRecord::Migration[6.0]
-  def change
-    content_models = [Katello::Rpm, Katello::ModuleStream, Katello::Erratum, Katello::PackageGroup, Katello::YumMetadataFile,
-                      Katello::Srpm, Katello::FileUnit, Katello::DockerManifestList, Katello::DockerManifest, Katello::DockerTag,
-                      Katello::Deb]
-
-    content_models.each do |model|
-      add_column model.table_name, :missing_from_migration, :bool, :default => false, :null => false
-      add_column model.table_name, :ignore_missing_from_migration, :bool, :default => false, :null => false
-    end
-  end
-end

data/db/migrate/20210420140050_add_pulp3_hrefs_to_content_types_deb.rb

@@ -1,5 +0,0 @@
-class AddPulp3HrefsToContentTypesDeb < ActiveRecord::Migration[6.0]
-  def change
-    add_column Katello::Deb.table_name, :migrated_pulp3_href, :string, :default => nil, :null => true
-  end
-end

data/lib/katello/tasks/check_config.rake

@@ -1,11 +0,0 @@
-namespace :katello do
-  task :check_config => ['environment'] do
-    desc "Task that can be run before a content migration to check that the configuration valid"
-    fail_msg = _("The system appears to already be using pulp3 with all content migrated.")
-
-    puts "Checking for valid Katello configuraton."
-    if SETTINGS[:katello][:use_pulp_2_for_content_type].nil?
-      fail fail_msg
-    end
-  end
-end

data/lib/katello/tasks/fix_hostgroup_facets.rake

@@ -1,8 +0,0 @@
-namespace :katello do
-  desc "This task collates hostgroup content facts that were missed during the upgrade from audit.\
-        It then updates the hostgroup content_facet accordingly."
-  task :fix_hostgroup_facets => :environment do
-    User.current = User.anonymous_admin
-    ::Katello::Util::HostgroupFacetsHelper.new.main
-  end
-end

data/lib/katello/tasks/pulp3_migration_approve_corrupted.rake

@@ -1,21 +0,0 @@
-namespace :katello do
-  desc "Marks corrupted or missing content as approved to be ignored during the migration"
-  task :approve_corrupted_migration_content => ["dynflow:client"] do
-    services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
-    Katello::Ping.ping!(services: services)
-
-    Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
-      type.missing_migrated_content.update_all(:ignore_missing_from_migration => true)
-    end
-    puts "Any missing or corrupt content will be ignored on migration to Pulp 3.  This can be undone with 'foreman-rake katello:unapprove_corrupted_migration_content'"
-  end
-
-  task :unapprove_corrupted_migration_content => ["dynflow:client"] do
-    services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
-    Katello::Ping.ping!(services: services)
-    Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
-      type.ignored_missing_migrated_content.update_all(:ignore_missing_from_migration => false)
-    end
-    puts "Resetting approval on any corrupted or missing content, you may want to re-run the 'foreman-maintain content prepare' step to attempt re-migration."
-  end
-end

data/lib/katello/tasks/pulp3_migration_reset.rake

@@ -1,26 +0,0 @@
-namespace :katello do
-  desc "Reset the Pulp 2 -> Pulp 3 migration for content types that haven't been fully switched over"
-  task :pulp3_migration_reset => ["dynflow:client", "check_ping"] do
-    puts "Starting Content Migration Reset."
-    SmartProxy.pulp_primary.refresh
-
-    task = ForemanTasks.async_task(Actions::Pulp3::ContentMigrationReset, SmartProxy.pulp_primary)
-
-    if ENV['wait'].nil? || ::Foreman::Cast.to_bool(ENV['wait'])
-      until !task.pending? || task.paused?
-        sleep(20)
-        task = ForemanTasks::Task.find(task.id)
-      end
-
-      if task.result == 'warning' || task.result == 'pending'
-        msg = _("Content Migration Reset failed, You will want to investigate: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}\n")
-        $stderr.print(msg)
-        fail ForemanTasks::TaskError, task
-      else
-        puts _("Content Migration Reset completed successfully")
-      end
-    else
-      puts "Content Migration Reset started, you may monitor it at: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}"
-    end
-  end
-end

data/lib/katello/tasks/reports.rake

@@ -1,7 +0,0 @@
-load "#{Rails.root}/lib/tasks/reports.rake"
-
-#Katello reports can generate a foreman task, so mark the task as a dynflow client
-["reports:daily", "reports:weekly", "reports:monthly"].each do |task|
-  Rake::Task[task].clear
-  Rake::Task[task].enhance ["dynflow:client"]
-end

data/lib/katello/tasks/upgrades/3.10/update_gpg_key_urls.rake

@@ -1,32 +0,0 @@
-namespace :katello do
-  namespace :upgrades do
-    namespace '3.10' do
-      desc "Update repositories with API V1 GPG URLs"
-      task :update_gpg_key_urls => ["environment", "katello:check_ping"] do
-        User.current = User.anonymous_admin
-
-        ::Organization.all.each do |org|
-          org_contents = Katello::Resources::Candlepin::Content.all(org.label, include_only: [:id, :gpgUrl])
-
-          org_contents.each do |cp_content|
-            gpg_url = cp_content['gpgUrl']
-            if gpg_url&.match(/katello\/api\/repositories/)
-              content = Katello::Content.where(cp_content_id: cp_content['id'], organization: org).first
-
-              if content.nil?
-                Rails.logger.warn("Candlepin Content id=#{cp_content['id']} isn't in our DB. Try running 'rake katello:reimport' first.")
-              else
-                root_repo = Katello::RootRepository.in_organization(org).where(content_id: content.cp_content_id).first
-                new_gpg_url = root_repo.library_instance.yum_gpg_key_url
-                cp_content['gpgUrl'] = new_gpg_url
-                Katello::Resources::Candlepin::Content.update(org.label, cp_content)
-                content.gpg_url = new_gpg_url
-                content.save!
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/webpack/components/TypeAhead/pf4Search/TypeAheadSearch.scss

@@ -1,5 +0,0 @@
-// accounting for excess padding on search bar and aligning vertically
-.foreman-pf4-search-clear {
-  padding: 8px 5px 4px 5px;
-  margin-left: 10px; 
-}

data/webpack/scenes/ContentViews/Table/actionResolver.js

@@ -1,28 +0,0 @@
-const actionResolver = (rowData, { _rowIndex }) => {
-  // don't show actions for the expanded parts
-  if (rowData.parent || rowData.compoundParent || rowData.noactions) return null;
-
-  // printing to the console for now until these are hooked up
-  /* eslint-disable no-console */
-  return [
-    {
-      title: 'Publish and Promote',
-      onClick: (_event, rowId, _rowInfo) => console.log(`clicked on row ${rowId}`),
-    },
-    {
-      title: 'Promote',
-      onClick: (_event, rowId, _rowInfo) => console.log(`clicked on row ${rowId}`),
-    },
-    {
-      title: 'Copy',
-      onClick: (_event, rowId, _rowInfo) => console.log(`clicked on row ${rowId}`),
-    },
-    {
-      title: 'Delete',
-      onClick: (_event, rowId, _rowInfo) => console.log(`clicked on row ${rowId}`),
-    },
-  ];
-  /* eslint-enable no-console */
-};
-
-export default actionResolver;