katello 3.14.0.rc1 → 3.14.0.rc2

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

@@ -1,216 +0,0 @@
-#
-module Actions
-  module Candlepin
-    class SuspendedAction
-      def initialize(suspended_action)
-        @suspended_action = suspended_action
-      end
-
-      def notify_message_received(id, subject, content)
-        @suspended_action << Actions::Candlepin::ListenOnCandlepinEvents::Event[id, subject, content]
-      end
-
-      def notify_fatal(error)
-        @suspended_action << Actions::Candlepin::ListenOnCandlepinEvents::Fatal[error.backtrace && error.backtrace.join('\n'), error.message, error.class.name]
-      end
-
-      def notify_connected
-        @suspended_action << Actions::Candlepin::ListenOnCandlepinEvents::Connected
-      end
-
-      def notify_not_connected(message)
-        ForemanTasks.dynflow.world.clock.ping(@suspended_action, 5, Actions::Candlepin::ListenOnCandlepinEvents::Reconnect[message])
-      end
-
-      def notify_finished
-        @suspended_action << Actions::Candlepin::ListenOnCandlepinEvents::Close
-      end
-    end
-
-    class ListenOnCandlepinEvents < Actions::Base
-      include ::Dynflow::Action::Singleton
-
-      Connected = Algebrick.atom
-
-      Reconnect = Algebrick.type do
-        fields! message: String
-      end
-
-      Event = Algebrick.type do
-        fields! message_id: String, subject: String, content: String
-      end
-
-      Fatal = Algebrick.type do
-        fields! backtrace: String, message: String, kind: String
-      end
-
-      Close = Algebrick.atom
-
-      class << self
-        attr_reader :triggered_action
-
-        def ensure_running(world = ForemanTasks.dynflow.world)
-          unless self.singleton_locked?(world)
-            @triggered_action = ForemanTasks.trigger self
-          end
-        rescue Dynflow::Coordinator::LockError
-          return false
-        end
-      end
-
-      def plan
-        # Make sure we don't have two concurrent listening services competing
-        plan_self
-      end
-
-      def run(event = nil)
-        match(event,
-              (on nil do
-                # initialize the listening service
-                initialize_service
-              end),
-              (on Reconnect do
-                 connect_listening_service(event)
-               end),
-              (on Connected do
-                 poll_listening_service(event)
-               end),
-              (on Event do
-                 # react on the event, probably calling ForemanTasks.async_task
-                 act_on_event(event)
-               end),
-              (on Close | Dynflow::Action::Cancellable::Cancel do
-                 # we finished with the listening serivce
-                 close_service
-               end),
-              (on Fatal do
-                 close_service_with_error(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 close_service_with_error(event)
-        error = Exception.new("#{event.kind}: #{event.message}")
-        error.set_backtrace([event.backtrace])
-        error!(error)
-      ensure
-        close_service
-      end
-
-      def connect_listening_service(event)
-        CandlepinListeningService.instance.close
-        output[:error] = event.message
-
-        suspend do |suspended_action|
-          CandlepinListeningService.instance.start(SuspendedAction.new(suspended_action))
-        end
-      end
-
-      def poll_listening_service(_event)
-        output[:connection] = "Connected"
-        output[:error] = nil
-        suspend do |suspended_action|
-          CandlepinListeningService.instance.poll_for_messages(SuspendedAction.new(suspended_action))
-        end
-      end
-
-      def initialize_service
-        output[:messages] = 0
-        output[:last_message] = nil
-        suspend do |suspended_action|
-          #send back @event_type by wake up action like
-          # suspended_action << @event_type
-          begin
-            initialize_listening_service(SuspendedAction.new(suspended_action))
-          rescue => e
-            error!(e)
-            raise e
-          end
-          unless Rails.env.test?
-            world.before_termination do
-              finish_service
-            end
-          end
-        end
-      end
-
-      def finish_service
-        log_prefix = "Finishing #{self.class.name} #{task.id}"
-        action_logger.info(log_prefix)
-        # make sure we close the service at exit to finish the listening action
-        suspended_action.ask(Close).wait
-        # if the triggered_action is nil, it means the action was resumed from
-        # previous run due to some unexpected termination of previous process
-        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
-              action_logger.info("#{log_prefix}: attempt #{attempt}/#{max_attempts}")
-              if attempt == max_attempts
-                action_logger.info("#{log_prefix} failed, skipping")
-              else
-                sleep 1
-              end
-            end
-          end
-        end
-      end
-
-      def act_on_event(event)
-        begin
-          output[:connection] = "Connected"
-          Actions::Candlepin::ImportPoolHandler.new(Rails.logger).handle(event)
-          output[:last_message] = "#{event.message_id} - #{event.subject}"
-          output[:last_message_time] = Time.now.to_s
-          output[:messages] = event.message_id
-        rescue => 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
-
-      def configured?
-        SETTINGS[:katello].key?(:qpid) &&
-          SETTINGS[:katello][:qpid].key?(:url) &&
-          SETTINGS[:katello][:qpid].key?(:subscriptions_queue_address)
-      end
-
-      def initialize_listening_service(suspended_action)
-        if configured?
-          CandlepinListeningService.initialize(world.logger,
-                                             SETTINGS[:katello][:qpid][:url],
-                                             SETTINGS[:katello][:qpid][:subscriptions_queue_address])
-          suspended_action.notify_not_connected("initialized...have not connected yet")
-        else
-          action_logger.error("katello has not been configured for qpid.url and qpid.subscriptions_queue_address")
-          suspended_action.notify_finished
-        end
-      rescue => e
-        Rails.logger.error(e.message)
-        Rails.logger.error(e.backtrace)
-        error!(e)
-      end
-
-      def error_message(error_id)
-        CandlepinListeningService.instance.errors[error_id]
-      end
-
-      def close_service
-        CandlepinListeningService.close
-      end
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-module Actions
-  module Katello
-    module EventQueue
-      class Monitor < Actions::Base
-        include ::Dynflow::Action::Singleton
-
-        Count = Algebrick.type do
-          fields! count: Integer, time: Time
-        end
-
-        Fatal = Algebrick.type do
-          fields! backtrace: String, message: String, kind: String
-        end
-
-        Ready = Algebrick.atom
-        Close = Algebrick.atom
-
-        class << self
-          attr_reader :triggered_action
-
-          def ensure_running(world = ForemanTasks.dynflow.world)
-            unless self.singleton_locked?(world)
-              @triggered_action = ForemanTasks.trigger self
-            end
-          rescue Dynflow::Coordinator::LockError
-            return false
-          end
-        end
-
-        def plan
-          # Make sure we don't have two concurrent listening services competing
-          plan_self
-        end
-
-        def run(event = nil)
-          action_logger.debug("message_queue_event: #{event}")
-          match(event,
-                (on nil do
-                  initialize_service
-                end),
-                (on Ready do
-                  listen_for_events
-                end),
-                (on Count do
-                   update_count(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 update_count(event)
-          output[:count] ||= 0
-          output[:count] += event.count
-          output[:last_count_update] = event.time
-          suspend
-        end
-
-        def humanized_name
-          _('Monitor Event Queue')
-        end
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-module Actions
-  module Katello
-    module EventQueue
-      class PollerThread
-        SLEEP_INTERVAL = 2
-        COUNT_UPDATE_INTERVAL = 250
-        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 run_event(event)
-          @logger.debug("event_queue_event: type=#{event.event_type}, object_id=#{event.object_id}")
-
-          event_instance = nil
-          begin
-            ::User.as_anonymous_admin do
-              event_instance = ::Katello::EventQueue.create_instance(event)
-              event_instance.run
-            end
-          rescue => e
-            @logger.error("event_queue_error: type=#{event.event_type}, object_id=#{event.object_id}")
-            @logger.error(e.message)
-            @logger.error(e.backtrace.join("\n"))
-          ensure
-            if event_instance.try(:retry)
-              result = ::Katello::EventQueue.reschedule_event(event)
-              if result == :expired
-                @logger.warn("event_queue_event_expired: type=#{event.event_type} object_id=#{event.object_id}")
-              elsif !result.nil?
-                @logger.warn("event_queue_rescheduled: type=#{event.event_type} object_id=#{event.object_id}")
-              end
-            end
-            ::Katello::EventQueue.clear_events(event.event_type, event.object_id, event.created_at)
-          end
-        end
-
-        def poll_for_events(suspended_action)
-          @thread.kill if @thread
-          @thread = Thread.new do
-            loop do
-              Rails.application.executor.wrap do
-                begin
-                  count = 0
-
-                  until (event = ::Katello::EventQueue.next_event).nil?
-                    run_event(event)
-                    count += 1
-
-                    if count > COUNT_UPDATE_INTERVAL
-                      suspended_action.notify_count(count)
-                      count = 0
-                    end
-                  end
-
-                  suspended_action.notify_count(count) if count > 0
-                  sleep SLEEP_INTERVAL
-                rescue => e
-                  suspended_action.notify_fatal(e)
-                  raise e
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Actions
-  module Katello
-    module EventQueue
-      class SuspendedAction
-        def initialize(suspended_action)
-          @suspended_action = suspended_action
-        end
-
-        def notify_count(processed_count)
-          @suspended_action << Monitor::Count[processed_count, Time.now]
-        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