katello 3.1.0.rc1 → 3.1.0.rc2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae4ab15eb9d39a34a4069ff9b54905840aaf73af
-  data.tar.gz: bf8993794d13a72a10086070b705af01bb006be9
+  metadata.gz: 395d8a31c2395972b2f577bb9355592371adfbcc
+  data.tar.gz: a606dbd1a2f6272f690beb0e88fa3a1557eafddc
 SHA512:
-  metadata.gz: e0c4e3472f5e0c95405197c1f55c17e0b7fa3ea60319b0ce0d8089878616d3f8ba72f3adefc678f17a6ae6289a0a2314c9a1791f3a12d892370fd09958ab7564
-  data.tar.gz: 29a7dadc2e1913b3761d182c10fd47937a8d0badb08bd2801e3e80918cb0d57601f59c72f27e90a9dd8e2a7912169a902ba16babf5f5b5cddd8da0f6c4eed13b
+  metadata.gz: 579ca099fa9cf2b6477c8795ccbcdfb37fa2e51bb93975c628a9134191bb9f983d2e6e466af98833213647e62b833c077d7d8000f7e0b0ac89bfe05c706858fe
+  data.tar.gz: 4f018616bf7be9e2fd7ff9243963728757cdd0ecc183409a32fb2e257907dfc0ede3e078da93bf004b3f01660318456e0a2d507bc63e76074d1b328727854ee4

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -132,7 +132,7 @@ module Katello
     #param :id, String, :desc => N_("UUID of the consumer"), :required => true
     def upload_package_profile
       User.as_anonymous_admin do
-        sync_task(::Actions::Katello::Host::UploadPackageProfile, @host, params[:_json])
+        async_task(::Actions::Katello::Host::UploadPackageProfile, @host, params[:_json])
       end
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end

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

@@ -99,9 +99,11 @@ module Katello
       query = PuppetModule.in_repositories(repositories)
       query = query.where(:name => params[:name]) if params[:name]
       query = query.where("#{PuppetModule.table_name}.uuid NOT in (?)", current_uuids) if current_uuids.present?
+      custom_sort = ->(sort_query) { sort_query.order('author, name, sortable_version DESC') }
 
       respond_for_index :template => 'puppet_modules',
-                        :collection => scoped_search(query, 'name', 'ASC', :resource_class => PuppetModule)
+                        :collection => scoped_search(query, nil, nil, :resource_class => PuppetModule,
+                                                     :custom_sort => custom_sort)
     end
 
     api :GET, "/content_views/:id/available_puppet_module_names",

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

@@ -55,7 +55,7 @@ module Katello
 
     def filter_by_content_view(filter, collection)
       repos = Katello::ContentView.find(filter.content_view_id).repositories
-      uuid = repos.map { |r| r.send("errata").pluck("uuid") }
+      uuid = repos.map { |r| r.send("errata").pluck("uuid") }.flatten
       filter_by_ids(uuid, collection)
     end
 

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

@@ -28,7 +28,12 @@ module Katello
       end
 
       collection = scoped_search(index_relation, 'updated_at', 'desc', :resource_class => Erratum, :includes => [:cves])
-      @installable_errata_ids = @host.content_facet.installable_errata.pluck("#{Katello::Erratum.table_name}.id")
+
+      @installable_errata_ids = []
+      if @host.content_facet
+        @installable_errata_ids = @host.content_facet.installable_errata.pluck("#{Katello::Erratum.table_name}.id")
+      end
+
       respond_for_index :collection => collection
     end
 
@@ -52,7 +57,11 @@ module Katello
     protected
 
     def index_relation
-      @host.content_facet.installable_errata(@environment, @content_view)
+      relation = Katello::Erratum.none
+      if @host.content_facet
+        relation = @host.content_facet.installable_errata(@environment, @content_view)
+      end
+      relation
     end
 
     private

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

@@ -110,9 +110,9 @@ module Katello
     param :label, String, :desc => N_("Organization label")
     def download_debug_certificate
       pem = @organization.debug_cert
-      data = "#{ pem[:key] }\n\n#{ pem[:cert] }"
+      data = "#{pem[:key]}\n\n#{pem[:cert]}"
       send_data data,
-                :filename => "#{ @organization.name }-key-cert.pem",
+                :filename => "#{@organization.name}-key-cert.pem",
                 :type => "application/text"
     end
 

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

@@ -47,7 +47,7 @@ module Katello
     param :erratum_id, String, :desc => N_("Id of an erratum to find repositories that contain the erratum")
     param :rpm_id, String, :desc => N_("Id of a package to find repositories that contain the rpm")
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
-    param :content_type, RepositoryTypeManager.repository_types.keys, :desc => (N_("limit to only repositories of this type"))
+    param :content_type, RepositoryTypeManager.repository_types.keys, :desc => N_("limit to only repositories of this type")
     param :name, String, :desc => N_("name of the repository"), :required => false
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' is supported."),
           :required => false
@@ -138,7 +138,7 @@ module Katello
                                      repo_params[:content_type], unprotected,
                                      gpg_key, repository_params[:checksum_type], repo_params[:download_policy])
       repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params[:mirror_on_sync]
+      repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
       sync_task(::Actions::Katello::Repository::Create, repository, false, true)
       repository = Repository.find(repository.id)
       respond_for_show(:resource => repository)

data/app/controllers/katello/concerns/filtered_auto_complete_search.rb

@@ -10,7 +10,7 @@ module Katello
           options = resource_class.respond_to?(:completer_scope_options) ? resource_class.completer_scope_options : {}
           items = resource_class.where(:id => self.index_relation).complete_for(params[:search], options)
           items = items.map do |item|
-            category = (['and', 'or', 'not', 'has'].include?(item.to_s.sub(/^.*\s+/, ''))) ? _('Operators') : ''
+            category = ['and', 'or', 'not', 'has'].include?(item.to_s.sub(/^.*\s+/, '')) ? _('Operators') : ''
             part = item.to_s.sub(/^.*\b(and|or)\b/i) { |match| match.sub(/^.*\s+/, '') }
             completed = item.to_s.chomp(part)
             {:completed => completed, :part => part, :label => item, :category => category}

data/app/controllers/katello/sync_management_controller.rb

@@ -63,11 +63,8 @@ module Katello
       repos.each do |repo|
         if latest_task(repo).try(:state) != 'running'
           ForemanTasks.async_task(::Actions::Katello::Repository::Sync, repo)
-          collected << format_sync_progress(repo)
-        else
-          notify.error N_("There is already an active sync process for the '%s' repository. Please try again later") %
-                          repo.name
         end
+        collected << format_sync_progress(repo)
       end
       collected
     end

data/app/helpers/katello/packages_helper.rb

@@ -1,7 +1,7 @@
 module Katello
   module PackagesHelper
     def format_changelog_changes(changes)
-      (h(changes).gsub(/\n/, "<br>")).html_safe
+      h(changes).gsub(/\n/, "<br>").html_safe
     end
 
     def format_changelog_date(date)

data/app/lib/actions/candlepin/candlepin_listening_service.rb

@@ -65,7 +65,7 @@ module Actions
 
       def fetch_message
         {:result => retrieve, :error => nil}
-      rescue Actions::Candlepin::ConnectionError => e
+      rescue ::Actions::Candlepin::ConnectionError => e
         {:result => nil, :error => e.message}
       end
 

data/app/lib/actions/candlepin/listen_on_candlepin_events.rb

@@ -180,10 +180,13 @@ module Actions
       def act_on_event(event)
         begin
           output[:connection] = "Connected"
-          on_event(event)
+          Actions::Candlepin::ImportPoolHandler.new(Rails.logger).handle(event)
+          output[:last_message] = "#{event.message_id} - #{event.subject}"
+          output[:messages] = event.message_id
         rescue => e
-          error!(e)
-          raise e
+          output[:last_event_error] = e.message
+          action_logger.error("Failed Candlepin Event: #{e.message}")
+          action_logger.error(e.backtrace.join('\n'))
         end
         suspend
       end
@@ -210,15 +213,6 @@ module Actions
         error!(e)
       end
 
-      def on_event(event)
-        Actions::Candlepin::ImportPoolHandler.new(Rails.logger).handle(event)
-        output[:last_message] = "#{event.message_id} - #{event.subject}"
-        output[:messages] = event.message_id
-      rescue => e
-        close_service
-        error!(e)
-      end
-
       def error_message(error_id)
         CandlepinListeningService.instance.errors[error_id]
       end

data/app/lib/actions/katello/capsule_content/sync.rb

@@ -71,7 +71,7 @@ module Actions
             repo_details = capsule.pulp_repo_facts(repo.pulp_id)
             next unless repo_details
             capsule_distributors = repo_details["distributors"]
-            !(repo.distributors_match?(capsule_distributors))
+            !repo.distributors_match?(capsule_distributors)
           end
         end
 
@@ -81,7 +81,7 @@ module Actions
             repo_details = capsule.pulp_repo_facts(repo.pulp_id)
             next unless repo_details
             capsule_importer = repo_details["importers"][0]
-            !(repo.importer_matches?(capsule_importer))
+            !repo.importer_matches?(capsule_importer)
           end
         end
 

data/app/lib/actions/katello/event_queue/monitor.rb

@@ -0,0 +1,129 @@
+module Actions
+  module Katello
+    module EventQueue
+      class Monitor < Actions::Base
+        Event = Algebrick.type do
+          fields! event_type: String, object_id: Integer, created_at: DateTime
+        end
+
+        Fatal = Algebrick.type do
+          fields! backtrace: String, message: String, kind: String
+        end
+
+        Ready = Algebrick.atom
+        Close = Algebrick.atom
+
+        cattr_accessor :triggered_action
+
+        def self.ensure_running(world = ForemanTasks.dynflow.world)
+          world.coordinator.acquire(RunOnceCoordinatorLock.new(world)) do
+            unless ForemanTasks::Task::DynflowTask.for_action(self).running.any?
+              self.triggered_action = ForemanTasks.trigger(self)
+            end
+          end
+        rescue Dynflow::Coordinator::LockError
+          return false
+        end
+
+        def plan
+          # Make sure we don't have two concurrent listening services competing
+          if already_running?
+            fail "Action #{self.class.name} is already active"
+          end
+          plan_self
+        end
+
+        def run(event = nil)
+          match(event,
+                (on nil do
+                  initialize_service
+                end),
+                (on Ready do
+                  listen_for_events
+                end),
+                (on Event do
+                   act_on_event(event)
+                 end),
+                (on Close | Dynflow::Action::Cancellable::Cancel do
+                   close_service
+                 end),
+                (on Fatal do
+                   restart_poller(event)
+                 end),
+                (on Dynflow::Action::Skip do
+                   # do nothing, just skip
+                 end))
+        rescue => e
+          action_logger.error(e.message)
+          close_service
+          error!(e)
+        end
+
+        def restart_poller(_event)
+          suspend do |suspended_action|
+            SuspendedAction.new(suspended_action).notify_ready
+          end
+        end
+
+        def close_service
+          PollerThread.close
+        end
+
+        def initialize_service
+          ::Katello::EventQueue.reset_in_progress
+          PollerThread.initialize(world.logger)
+          suspend do |suspended_action|
+            SuspendedAction.new(suspended_action).notify_ready
+
+            unless Rails.env.test?
+              world.before_termination do
+                finish_service
+              end
+            end
+          end
+        end
+
+        def finish_service
+          suspended_action.ask(Close).wait
+          if self.class.triggered_action
+            self.class.triggered_action.finished.wait
+          else
+            max_attempts = 10
+            (1..max_attempts).each do |attempt|
+              task.reload
+              if !task.pending? || task.paused?
+                break
+              else
+                sleep 1 if attempt != max_attempts
+              end
+            end
+          end
+        end
+
+        def listen_for_events
+          suspend do |suspended_action|
+            PollerThread.instance.poll_for_events(SuspendedAction.new(suspended_action))
+          end
+        end
+
+        def act_on_event(event)
+          User.as_anonymous_admin do
+            output[:last_event] = "#{event.event_type} - #{event.object_id}"
+            ::Katello::EventQueue.event_class(event.event_type).new(event.object_id).run
+          end
+        rescue => e
+          world.logger.error(e.message)
+          world.logger.error(e.backtrace.join("\n"))
+          output[:last_error] = e.message
+        ensure
+          ::Katello::EventQueue.clear_events(event.event_type, event.object_id, event.created_at)
+          suspend
+        end
+
+        def humanized_name
+          _('Monitor Event Queue')
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/event_queue/poller_thread.rb

@@ -0,0 +1,45 @@
+module Actions
+  module Katello
+    module EventQueue
+      class PollerThread
+        SLEEP_INTERVAL = 2
+        cattr_accessor :instance
+
+        def self.initialize(logger)
+          self.instance ||= self.new(logger)
+        end
+
+        def self.close
+          self.instance.close if self.instance
+          self.instance = nil
+        end
+
+        def initialize(logger)
+          @logger = logger
+        end
+
+        def close
+          @thread.kill if @thread
+        end
+
+        def poll_for_events(suspended_action)
+          @thread.kill if @thread
+          @thread = Thread.new do
+            loop do
+              begin
+                until (event = ::Katello::EventQueue.next_event).nil?
+                  suspended_action.notify_queue_item(event.event_type, event.object_id, event.created_at) if event
+                end
+
+                sleep SLEEP_INTERVAL
+              rescue => e
+                suspended_action.notify_fatal(e)
+                raise e
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/event_queue/run_once_coordinator_lock.rb

@@ -0,0 +1,12 @@
+module Actions
+  module Katello
+    module EventQueue
+      class RunOnceCoordinatorLock < Dynflow::Coordinator::LockByWorld
+        def initialize(world)
+          super
+          @data[:id] = 'katello-event-queue'
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/event_queue/suspended_action.rb

@@ -0,0 +1,23 @@
+module Actions
+  module Katello
+    module EventQueue
+      class SuspendedAction
+        def initialize(suspended_action)
+          @suspended_action = suspended_action
+        end
+
+        def notify_queue_item(event_type, object_id, created_at)
+          @suspended_action << Monitor::Event[event_type, object_id, created_at.to_datetime]
+        end
+
+        def notify_ready
+          @suspended_action << Monitor::Ready
+        end
+
+        def notify_fatal(error)
+          @suspended_action << Monitor::Fatal[error.backtrace && error.backtrace.join('\n'), error.message, error.class.name]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/host/generate_applicability.rb

@@ -13,9 +13,8 @@ module Actions
         end
 
         def finalize
-          ::Host.where(:id => input[:host_ids]).each do |host|
-            host.content_facet.try(:import_applicability)
-            host.content_facet.update_errata_status
+          input[:host_ids].each do |host_id|
+            ::Katello::EventQueue.push_event(::Katello::Events::ImportHostErrata::EVENT_TYPE, host_id)
           end
         end
       end

data/app/lib/actions/katello/host/update.rb

@@ -44,7 +44,7 @@ module Actions
 
         def humanized_name
           if input.try(:[], :hostname)
-            _('Update for host %s') % (input[:hostname])
+            _('Update for host %s') % input[:hostname]
           else
             _('Update for host')
           end

data/app/lib/actions/katello/repository/import_applicability.rb

@@ -11,7 +11,9 @@ module Actions
 
         def run
           repo = ::Katello::Repository.find(input[:repo_id])
-          repo.import_host_applicability
+          repo.hosts_with_applicability.each do |host|
+            ::Katello::EventQueue.push_event(::Katello::Events::ImportHostErrata::EVENT_TYPE, host.id)
+          end
         end
 
         def rescue_strategy_for_self