katello 3.18.0.rc1 → 4.0.0.rc1

data/app/controllers/katello/api/v2/gpg_keys_controller.rb

@@ -1,114 +0,0 @@
-module Katello
-  class Api::V2::GpgKeysController < Api::V2::ApiController
-    include Katello::Concerns::FilteredAutoCompleteSearch
-    before_action :deprecated
-    before_action :authorize
-    before_action :find_organization, :only => [:create, :index, :auto_complete_search]
-    before_action :find_gpg_key, :only => [:show, :update, :destroy, :content, :set_content]
-    skip_before_action :check_media_type, :only => [:create, :content, :set_content]
-
-    def_param_group :gpg_key do
-      param :name, :identifier, :action_aware => true, :required => true, :desc => N_("identifier of the gpg key")
-      param :content, String, :action_aware => true, :required => true, :desc => N_("public key block in DER encoding")
-    end
-
-    resource_description do
-      description <<-DESC
-        # Description
-        Documents the calls for the list, read, create, update and delete operations for GPG keys
-      DESC
-      api_version "v2"
-    end
-
-    api :GET, "/gpg_keys", N_("List gpg keys")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
-    param :name, String, :desc => N_("name of the GPG key"), :required => false
-    param_group :search, Api::V2::ApiController
-    add_scoped_search_description_for(GpgKey)
-    def index
-      respond(:collection => scoped_search(index_relation.distinct, :name, :asc))
-    end
-
-    def index_relation
-      query = GpgKey.readable.where(:organization_id => @organization.id)
-      query = query.where(:name => params[:name]) if params[:name]
-      query
-    end
-
-    api :POST, "/gpg_keys", N_("Create a gpg key")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
-    param_group :gpg_key, :as => :create
-    def create
-      filepath = params.try(:[], :file_path).try(:path)
-
-      content = nil
-      if filepath
-        content = File.open(filepath, "rb") { |file| file.read }
-      else
-        content = params[:content]
-      end
-
-      gpg_key = @organization.gpg_keys.create!(gpg_key_params.merge(:content => content))
-      respond_for_create(:resource => gpg_key)
-    end
-
-    api :GET, "/gpg_keys/:id", N_("Show a gpg key"), :deprecated => true
-    param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
-    def show
-      respond_for_show(:resource => @gpg_key)
-    end
-
-    api :PUT, "/gpg_keys/:id", N_("Update a repository"), :deprecated => true
-    param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
-    param_group :gpg_key
-    def update
-      sync_task(::Actions::Katello::GpgKey::Update, @gpg_key, gpg_key_params.to_h)
-
-      respond_for_show(:resource => @gpg_key)
-    end
-
-    api :DELETE, "/gpg_keys/:id", N_("Destroy a gpg key"), :deprecated => true
-    param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
-    def destroy
-      @gpg_key.destroy
-      respond_for_destroy
-    end
-
-    api :GET, "/gpg_keys/:id/content", N_("Return the content of a gpg key, used directly by yum"), :deprecated => true
-    param :id, :number, :required => true
-    def content
-      render(:plain => @gpg_key.content, :layout => false)
-    end
-
-    api :POST, "/gpg_keys/:id/content", N_("Upload gpg key contents"), :deprecated => true
-    param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
-    param :content, File, :desc => N_("file contents"), :required => true
-    def set_content
-      filepath = params.try(:[], :content).try(:path)
-
-      if filepath
-        content = File.open(filepath, "rb") { |file| file.read }
-        @gpg_key.update!(:content => content)
-        render :json => {:status => "success"}
-      else
-        fail HttpErrors::BadRequest, _("No file uploaded")
-      end
-    end
-
-    protected
-
-    def find_gpg_key
-      @gpg_key = GpgKey.find(params[:id])
-    rescue ActiveRecord::RecordNotFound
-      raise HttpErrors::NotFound, _("Couldn't find GPG key '%s'") % params[:id]
-    end
-
-    def gpg_key_params
-      params.permit(:name, :content)
-    end
-
-    def deprecated
-      ::Foreman::Deprecation.api_deprecation_warning("it will be removed in Katello 4.0, Please see /api/v2/content_credentials")
-    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/lib/katello/tasks/common.rake

@@ -1,7 +0,0 @@
-namespace :katello do
-  task :disable_dynflow do
-    #Ensures that we run as a dynflow 'client'
-    ::Rails.application.dynflow.initialize!
-    ForemanTasks.dynflow.config.remote = true
-  end
-end

data/lib/katello/tasks/reports.rake

@@ -1,4 +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 { |task| Rake::Task[task].enhance ["dynflow:client"] }

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/__mocks__/foremanReact/components/common/Fill/GlobalFill.js

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

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;