eventboss 1.0.0

data/lib/eventboss/polling/basic.rb

@@ -0,0 +1,68 @@
+module Eventboss
+  module Polling
+    class Basic
+      PAUSE_AFTER_EMPTY = 2 # seconds
+
+      def initialize(queues, timer = Time)
+        @queues = queues.to_a
+        @timer = timer
+        @paused_until = @queues.each_with_object(Hash.new) do |queue, hash|
+          hash[queue] = @timer.at(0)
+        end
+
+        reset_next_queue
+      end
+
+      def next_queue
+        next_active_queue
+      end
+
+      def messages_found(queue, messages_count)
+        if messages_count == 0
+          pause(queue)
+        else
+          reset_next_queue
+        end
+      end
+
+      def active_queues
+        @queues.reject { |q, _| queue_paused?(q) }
+      end
+
+      private
+
+      def next_active_queue
+        reset_next_queue if queues_unpaused_since?
+
+        size = @queues.length
+        size.times do
+          queue = @queues[@next_queue_index]
+          @next_queue_index = (@next_queue_index + 1) % size
+          return queue unless queue_paused?(queue)
+        end
+
+        nil
+      end
+
+      def queues_unpaused_since?
+        last = @last_unpause_check
+        now = @last_unpause_check = @timer.now
+
+        last && @paused_until.values.any? { |t| t > last && t <= now }
+      end
+
+      def reset_next_queue
+        @next_queue_index = 0
+      end
+
+      def queue_paused?(queue)
+        @paused_until[queue] > @timer.now
+      end
+
+      def pause(queue)
+        return unless PAUSE_AFTER_EMPTY > 0
+        @paused_until[queue] = @timer.now + PAUSE_AFTER_EMPTY
+      end
+    end
+  end
+end

data/lib/eventboss/polling/timed_round_robin.rb

@@ -0,0 +1,42 @@
+module Eventboss
+  module Polling
+    class TimedRoundRobin
+      PAUSE_AFTER_EMPTY = 2 # seconds
+
+      def initialize(queues, timer = Time)
+        @queues = queues.to_a
+        @timer = timer
+        @next_queue_index = 0
+        @paused_until = @queues.each_with_object(Hash.new) do |queue, hash|
+          hash[queue] = @timer.at(0)
+        end
+      end
+
+      def next_queue
+        size = @queues.length
+        size.times do
+          queue = @queues[@next_queue_index]
+          @next_queue_index = (@next_queue_index + 1) % size
+          return queue unless queue_paused?(queue)
+        end
+
+        nil
+      end
+
+      def messages_found(queue, messages_count)
+        pause(queue) if messages_count == 0
+      end
+
+      private
+
+      def queue_paused?(queue)
+        @paused_until[queue] > @timer.now
+      end
+
+      def pause(queue)
+        return unless PAUSE_AFTER_EMPTY > 0
+        @paused_until[queue] = @timer.now + PAUSE_AFTER_EMPTY
+      end
+    end
+  end
+end

data/lib/eventboss/publisher.rb

@@ -0,0 +1,32 @@
+module Eventboss
+  class Publisher
+    def initialize(event_name, sns_client, configuration, opts = {})
+      @event_name = event_name
+      @sns_client = sns_client
+      @configuration = configuration
+      @generic = opts[:generic]
+    end
+
+    def publish(payload)
+      sns_client.publish({
+        topic_arn: topic_arn,
+        message: json_payload(payload)
+      })
+    end
+
+    private
+
+    attr_reader :event_name, :sns_client, :configuration
+
+    def json_payload(payload)
+      payload.is_a?(String) ? payload : payload.to_json
+    end
+
+    def topic_arn
+      src_selector = @generic ? "" : "-#{configuration.eventboss_app_name}"
+
+      "arn:aws:sns:#{configuration.eventboss_region}:#{configuration.eventboss_account_id}:\
+eventboss#{src_selector}-#{event_name}-#{Eventboss.env}"
+    end
+  end
+end

data/lib/eventboss/queue.rb

@@ -0,0 +1,42 @@
+module Eventboss
+  class Queue
+    include Comparable
+    attr_reader :name
+
+    def self.build_name(source:, destination:, event:, env:, generic:)
+      source =
+        if generic
+          ''
+        else
+          "-#{source}"
+        end
+
+      "#{destination}-eventboss#{source}-#{event}-#{env}"
+    end
+
+    def initialize(name, configuration = Eventboss.configuration)
+      @client = configuration.sqs_client
+      @name = name
+    end
+
+    def url
+      @url ||= client.get_queue_url(queue_name: name).queue_url
+    end
+
+    def <=>(another_queue)
+      name <=> another_queue&.name
+    end
+
+    def eql?(another_queue)
+      name == another_queue&.name
+    end
+
+    def hash
+      name.hash
+    end
+
+    private
+
+    attr_reader :client
+  end
+end

data/lib/eventboss/queue_listener.rb

@@ -0,0 +1,11 @@
+module Eventboss
+  class QueueListener
+    class << self
+      def list
+        Hash[Eventboss::Listener::ACTIVE_LISTENERS.map do |src_app_event, listener|
+          [Eventboss::Queue.new("#{Eventboss.configuration.eventboss_app_name}#{Eventboss.configuration.sns_sqs_name_infix}#{src_app_event}-#{Eventboss.env}"), listener]
+        end]
+      end
+    end
+  end
+end

data/lib/eventboss/railtie.rb

@@ -0,0 +1,5 @@
+class Eventboss::Railtie < Rails::Railtie
+  rake_tasks do
+    load 'tasks/eventboss.rake'
+  end
+end

data/lib/eventboss/runner.rb

@@ -0,0 +1,60 @@
+module Eventboss
+  class Runner
+    class << self
+      def launch
+        queues = Eventboss::QueueListener.list
+        client = Eventboss.configuration.sqs_client
+        config = Eventboss.configuration
+
+        Eventboss::Instrumentation.add(queues)
+
+        launcher = Launcher.new(queues, client, worker_count: config.concurrency)
+
+        self_read, _self_write = IO.pipe
+        begin
+          launcher.start
+          while (_readable_io = IO.select([self_read]))
+            # handle_signal(readable_io.first[0].gets.strip)
+          end
+        rescue Interrupt
+          launcher.stop
+          exit 0
+        end
+      end
+
+      def start
+        configuration = Eventboss.configuration
+
+        queue_listeners = Eventboss::QueueListener.list
+        Eventboss::Instrumentation.add(queue_listeners)
+        polling_strategy = configuration.polling_strategy.call(queue_listeners.keys)
+
+        fetcher = Eventboss::Fetcher.new(configuration)
+        executor = Concurrent.global_io_executor
+
+        manager = Eventboss::Manager.new(
+          fetcher,
+          polling_strategy,
+          executor,
+          queue_listeners,
+          configuration.concurrency,
+          configuration.error_handlers
+        )
+
+        manager.start
+
+        self_read, self_write = IO.pipe
+        begin
+          while (readable_io = IO.select([self_read]))
+            signal = readable_io.first[0].gets.strip
+            # handle_signal(signal)
+          end
+        rescue Interrupt
+          executor.shutdown
+          executor.wait_for_termination
+          exit 0
+        end
+      end
+    end
+  end
+end

data/lib/eventboss/safe_thread.rb

@@ -0,0 +1,23 @@
+module Eventboss
+  # SafeThread includes thread handling with automatic error reporting
+  module SafeThread
+    def safe_thread(name)
+      Thread.new do
+        begin
+          Thread.current[:ah_eventboss_label] = name
+          yield
+        rescue Exception => exception
+          handle_exception(exception, name: name)
+          raise exception
+        end
+      end
+    end
+
+    def handle_exception(exception, context)
+      context.freeze
+      Eventboss.configuration.error_handlers.each do |handler|
+        handler.call(exception, context)
+      end
+    end
+  end
+end

data/lib/eventboss/scripts.rb

@@ -0,0 +1 @@
+load 'tasks/eventboss.rake'

data/lib/eventboss/sender.rb

@@ -0,0 +1,25 @@
+module Eventboss
+  class Sender
+    def initialize(client:, queue:)
+      @client = client
+      @queue = queue
+    end
+
+    def send_batch(payload)
+      client.send_message_batch(
+        queue_url: queue.url,
+        entries: Array(build_entries(payload))
+      )
+    end
+
+    private
+
+    attr_reader :queue, :client
+
+    def build_entries(messages)
+      messages.map do |message|
+        { id: SecureRandom.hex, message_body: message.to_json }
+      end
+    end
+  end
+end

data/lib/eventboss/sns_client.rb

@@ -0,0 +1,55 @@
+module Eventboss
+  class NotConfigured < StandardError; end
+
+  class SnsClient
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def publish(payload)
+      backend.publish(payload)
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def backend
+      if configured?
+        options = {
+          region: configuration.eventboss_region,
+          credentials: ::Aws::Credentials.new(
+            configuration.aws_access_key_id,
+            configuration.aws_secret_access_key
+          )
+        }
+        if configuration.aws_sns_endpoint
+          options[:endpoint] = configuration.aws_sns_endpoint
+        end
+        Aws::SNS::Client.new(
+          options
+        )
+      elsif configuration.raise_on_missing_configuration
+        raise NotConfigured, 'Eventboss is not configured'
+      else
+        Mock.new
+      end
+    end
+
+    def configured?
+      !!(
+        configuration.eventboss_region &&
+        configuration.eventboss_account_id &&
+        configuration.eventboss_app_name
+      )
+    end
+
+    class Mock
+      def publish(_)
+        Eventboss::Logger.info('Eventboss is not configured. Skipping message publishing!')
+        return
+      end
+    end
+  end
+
+end

data/lib/eventboss/unit_of_work.rb

@@ -0,0 +1,33 @@
+module Eventboss
+  # UnitOfWork handles calls a listener for each message and deletes on success
+  class UnitOfWork
+    include Logging
+    include SafeThread
+
+    attr_accessor :queue, :listener, :message
+
+    def initialize(queue, listener, message)
+      @queue = queue
+      @listener = listener
+      @message = message
+    end
+
+    def run(client)
+      logger.debug('Started', @message.message_id)
+      processor = @listener.new
+      processor.receive(JSON.parse(@message.body))
+      logger.info('Finished', @message.message_id)
+    rescue StandardError => exception
+      handle_exception(exception, processor: processor, message_id: @message.message_id)
+    else
+      cleanup(client)
+    end
+
+    def cleanup(client)
+      client.delete_message(
+        queue_url: @queue.url, receipt_handle: @message.receipt_handle
+      )
+      logger.debug('Deleting', @message.message_id)
+    end
+  end
+end

data/lib/eventboss/version.rb

@@ -0,0 +1,3 @@
+module Eventboss
+  VERSION = "1.0.0"
+end

data/lib/eventboss/worker.rb

@@ -0,0 +1,55 @@
+module Eventboss
+  # Worker is part of a pool of workers, handles UnitOfWork lifecycle
+  class Worker
+    include Logging
+    include SafeThread
+
+    attr_reader :id
+
+    def initialize(launcher, id, client, bus)
+      @id = "worker-#{id}"
+      @launcher = launcher
+      @client = client
+      @bus = bus
+      @thread = nil
+    end
+
+    def start
+      @thread = safe_thread(id, &method(:run))
+    end
+
+    def run
+      while (work = @bus.pop)
+        work.run(@client)
+      end
+      @launcher.worker_stopped(self)
+    rescue Eventboss::Shutdown
+      @launcher.worker_stopped(self)
+    rescue Exception => exception
+      handle_exception(exception, worker_id: id)
+      # Restart the worker in case of hard exception
+      # Message won't be delete from SQS and will be visible later
+      @launcher.worker_stopped(self, restart: true)
+    end
+
+    def terminate(wait = false)
+      stop_token
+      return unless @thread
+      @thread.value if wait
+    end
+
+    def kill(wait = false)
+      stop_token
+      return unless @thread
+      @thread.raise Eventboss::Shutdown
+      @thread.value if wait
+    end
+
+    private
+
+    # stops the loop, by enqueuing falsey value
+    def stop_token
+      @bus << nil
+    end
+  end
+end