katello 3.18.0.rc2.1 → 4.0.0.rc2

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/lib/actions/pulp/consumer/abstract_content_action.rb

@@ -1,71 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class AbstractContentAction < Pulp::AbstractAsyncTask
-        include Helpers::Presenter
-        include Actions::Pulp::ExpectOneTask
-
-        def external_task=(external_task_data)
-          super(external_task_data)
-          task_errors = find_errors(output[:pulp_tasks])
-          if task_errors.any?
-            fail ::Katello::Errors::PulpError, task_errors.join("\n")
-          end
-        end
-
-        def process_timeout
-          accept_timeout = Setting['content_action_accept_timeout']
-          finish_timeout = Setting['content_action_finish_timeout']
-          pulp_state = output[:pulp_tasks][0][:state]
-
-          if pulp_state == 'waiting'
-            cancel
-            fail _("Host did not respond within %s seconds. The task has been cancelled. Is katello-agent installed and goferd running on the Host?") % accept_timeout
-          elsif output[:client_accepted].nil?
-            output[:client_accepted] = Time.now.to_s
-            schedule_timeout(finish_timeout)
-          elsif pulp_state == 'running'
-            cancel
-            fail _("Host did not finish content action in %s seconds.  The task has been cancelled.") % finish_timeout
-          end
-        end
-
-        def find_errors(tasks)
-          messages = []
-          tasks.each do |pulp_task|
-            if pulp_task[:result] && pulp_task[:result][:details]
-              pulp_task[:result][:details].each_value do |result|
-                unless result[:succeeded]
-                  messages << result[:details][:message]
-                end
-              end
-            end
-          end
-          messages
-        end
-
-        # by default runcible puts whatever we pass into a hash under the 'name' key
-        # here we can make the unit hash more precise
-        def parse_units_for_type
-          return unless input[:args]
-
-          if input[:type] == 'rpm'
-            input[:args].collect do |unit|
-              ::Katello::Util::Package.parse_nvrea_nvre(unit) || unit
-            end
-          else
-            input[:args]
-          end
-        end
-
-        def presenter
-          Consumer::ContentPresenter.new(self)
-        end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/consumer/content_install.rb

@@ -1,43 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class ContentInstall < AbstractContentAction
-        include Helpers::Presenter
-        include Actions::Pulp::ExpectOneTask
-
-        input_format do
-          param :consumer_uuid, String
-          param :type, %w(rpm package_group erratum)
-          param :args, array_of(String)
-        end
-
-        def invoke_external_task
-          task = pulp_extensions.consumer.install_content(input[:consumer_uuid],
-                                                   input[:type],
-                                                   parse_units_for_type,
-                                                    "importkeys" => true)
-          schedule_timeout(Setting['content_action_accept_timeout'])
-          task
-        end
-
-        def finalize
-          check_error_details
-        end
-
-        def check_error_details
-          output[:pulp_tasks].each do |pulp_task|
-            error_details = pulp_task.try(:[], "result").try(:[], "details").try(:[], "rpm").try(:[], "details").try(:[], "trace")
-            error_message = pulp_task.try(:[], "result").try(:[], "details").try(:[], "rpm").try(:[], "details").try(:[], "message")
-            if error_details&.include?("YumDownloadError") && error_message
-              fail _("An error occurred during the sync \n%{error_message}") % {:error_message => error_details}
-            end
-          end
-        end
-
-        def presenter
-          Consumer::ContentPresenter.new(self)
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/consumer/content_uninstall.rb

@@ -1,26 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class ContentUninstall < AbstractContentAction
-        include Helpers::Presenter
-        include Actions::Pulp::ExpectOneTask
-
-        input_format do
-          param :consumer_uuid, String
-          param :type, %w(rpm package_group)
-          param :args, array_of(String)
-        end
-
-        def invoke_external_task
-          pulp_extensions.consumer.uninstall_content(input[:consumer_uuid],
-                                                     input[:type],
-                                                     parse_units_for_type)
-        end
-
-        def presenter
-          Consumer::ContentPresenter.new(self)
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/consumer/content_update.rb

@@ -1,32 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class ContentUpdate < AbstractContentAction
-        include Helpers::Presenter
-        include Actions::Pulp::ExpectOneTask
-
-        input_format do
-          param :consumer_uuid, String
-          param :type, %w(rpm)
-          param :args, array_of(String)
-        end
-
-        def invoke_external_task
-          options = { "importkeys" => true }
-          options[:all] = true if input[:args].blank?
-
-          task = pulp_extensions.consumer.update_content(input[:consumer_uuid],
-                                                         input[:type],
-                                                         parse_units_for_type,
-                                                         options)
-          schedule_timeout(Setting['content_action_accept_timeout'])
-          task
-        end
-
-        def presenter
-          Consumer::ContentPresenter.new(self)
-        end
-      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