outboxer 0.1.11 → 1.0.0.pre.beta

data/lib/outboxer/messages.rb

@@ -0,0 +1,232 @@
+module Outboxer
+  module Messages
+    extend self
+
+    def counts_by_status
+      ActiveRecord::Base.connection_pool.with_connection do
+        status_counts = Models::Message::STATUSES.each_with_object({ all: 0 }) do |status, hash|
+          hash[status.to_sym] = 0
+        end
+
+        Models::Message.group(:status).count.each do |status, count|
+          status_counts[status.to_sym] = count
+          status_counts[:all] += count
+        end
+
+        status_counts
+      end
+    end
+
+    def queue(limit: 1)
+      ActiveRecord::Base.connection_pool.with_connection do
+        ActiveRecord::Base.transaction do
+          messages = Models::Message
+            .where(status: Models::Message::Status::BACKLOGGED)
+            .order(updated_at: :asc)
+            .lock('FOR UPDATE SKIP LOCKED')
+            .limit(limit)
+            .select(:id, :messageable_type, :messageable_id)
+
+          if messages.present?
+            Models::Message
+              .where(id: messages.map { |message| message[:id] })
+              .update_all(updated_at: Time.current, status: Models::Message::Status::QUEUED)
+          end
+
+          messages.map do |message|
+            {
+              id: message.id,
+              messageable_type: message.messageable_type,
+              messageable_id: message.messageable_id
+            }
+          end
+        end
+      end
+    end
+
+    LIST_STATUS_OPTIONS = [nil, :backlogged, :queued, :publishing, :failed]
+    LIST_STATUS_DEFAULT = nil
+
+    LIST_SORT_OPTIONS = [:id, :status, :messageable, :created_at, :updated_at]
+    LIST_SORT_DEFAULT = :updated_at
+
+    LIST_ORDER_OPTIONS = [:asc, :desc]
+    LIST_ORDER_DEFAULT = :asc
+
+    LIST_PAGE_DEFAULT = 1
+
+    LIST_PER_PAGE_OPTIONS = [10, 100, 200, 500, 1000]
+    LIST_PER_PAGE_DEFAULT = 100
+
+    def list(status: LIST_STATUS_DEFAULT,
+             sort: LIST_SORT_DEFAULT, order: LIST_ORDER_DEFAULT,
+             page: LIST_PAGE_DEFAULT, per_page: LIST_PER_PAGE_DEFAULT)
+      if !status.nil? && !LIST_STATUS_OPTIONS.include?(status.to_sym)
+        raise ArgumentError, "status must be #{LIST_STATUS_OPTIONS.join(' ')}"
+      end
+
+      if !LIST_SORT_OPTIONS.include?(sort.to_sym)
+        raise ArgumentError, "sort must be #{LIST_SORT_OPTIONS.join(' ')}"
+      end
+
+      if !LIST_ORDER_OPTIONS.include?(order.to_sym)
+        raise ArgumentError, "order must be #{LIST_ORDER_OPTIONS.join(' ')}"
+      end
+
+      if !page.is_a?(Integer) || page <= 0
+        raise ArgumentError, "page must be >= 1"
+      end
+
+      if !LIST_PER_PAGE_OPTIONS.include?(per_page.to_i)
+        raise ArgumentError, "per_page must be #{LIST_PER_PAGE_OPTIONS.join(' ')}"
+      end
+
+      message_scope = Models::Message
+      message_scope = status.nil? ? message_scope.all : message_scope.where(status: status)
+
+      message_scope =
+        if sort.to_sym == :messageable
+          message_scope.order(messageable_type: order, messageable_id: order)
+        else
+          message_scope.order(sort => order)
+        end
+
+      messages = ActiveRecord::Base.connection_pool.with_connection do
+        message_scope.page(page).per(per_page)
+      end
+
+      {
+        messages: messages.map do |message|
+          {
+            id: message.id,
+            status: message.status.to_sym,
+            messageable_type: message.messageable_type,
+            messageable_id: message.messageable_id,
+            created_at: message.created_at.utc,
+            updated_at: message.updated_at.utc
+          }
+        end,
+        total_pages: messages.total_pages,
+        current_page: messages.current_page,
+        limit_value: messages.limit_value,
+        total_count: messages.total_count
+      }
+    end
+
+    REPUBLISH_ALL_STATUSES = [:queued, :publishing, :failed]
+
+    def can_republish_all?(status:)
+      REPUBLISH_ALL_STATUSES.include?(status&.to_sym)
+    end
+
+    def republish_all(status:, batch_size: 100)
+      if !can_republish_all?(status: status)
+        status_formatted = status.nil? ? 'nil' : status
+
+        raise ArgumentError,
+          "Status #{status_formatted} must be one of #{REPUBLISH_ALL_STATUSES.join(', ')}"
+      end
+
+      republished_count = 0
+
+      loop do
+        republished_count_batch = 0
+
+        ActiveRecord::Base.connection_pool.with_connection do
+          ActiveRecord::Base.transaction do
+            locked_ids = Models::Message
+              .where(status: status)
+              .order(updated_at: :asc)
+              .limit(batch_size)
+              .lock('FOR UPDATE SKIP LOCKED')
+              .pluck(:id)
+
+            republished_count_batch = Models::Message
+              .where(id: locked_ids)
+              .update_all(status: Models::Message::Status::BACKLOGGED, updated_at: Time.now.utc)
+
+            republished_count += republished_count_batch
+          end
+        end
+
+        break if republished_count_batch < batch_size
+      end
+
+      { republished_count: republished_count }
+    end
+
+    def republish_selected(ids:)
+      ActiveRecord::Base.connection_pool.with_connection do
+        ActiveRecord::Base.transaction do
+          locked_ids = Models::Message
+            .where(id: ids)
+            .order(updated_at: :asc)
+            .lock('FOR UPDATE SKIP LOCKED')
+            .pluck(:id)
+
+          republished_count = Models::Message
+            .where(id: locked_ids)
+            .update_all(status: Models::Message::Status::BACKLOGGED, updated_at: Time.now.utc)
+
+          { republished_count: republished_count, not_republished_ids: ids - locked_ids }
+        end
+      end
+    end
+
+    def delete_all(status: nil, batch_size: 100)
+      deleted_count = 0
+
+      loop do
+        deleted_count_batch = 0
+
+        ActiveRecord::Base.connection_pool.with_connection do
+          ActiveRecord::Base.transaction do
+            query = Models::Message.all
+            query = query.where(status: status) unless status.nil?
+            locked_ids = query.order(:updated_at)
+              .limit(batch_size)
+              .lock('FOR UPDATE SKIP LOCKED')
+              .pluck(:id)
+
+            Models::Frame
+              .joins(:exception)
+              .where(exception: { message_id: locked_ids })
+              .delete_all
+
+            Models::Exception.where(message_id: locked_ids).delete_all
+
+            deleted_count_batch = Models::Message.where(id: locked_ids).delete_all
+          end
+        end
+
+        deleted_count += deleted_count_batch
+
+        break if deleted_count_batch < batch_size
+      end
+
+      { deleted_count: deleted_count }
+    end
+
+    def delete_selected(ids:)
+      ActiveRecord::Base.connection_pool.with_connection do
+        ActiveRecord::Base.transaction do
+          locked_ids = Models::Message
+            .where(id: ids)
+            .lock('FOR UPDATE SKIP LOCKED')
+            .pluck(:id)
+
+          Models::Frame
+            .joins(:exception)
+            .where(exception: { message_id: locked_ids })
+            .delete_all
+
+          Models::Exception.where(message_id: locked_ids).delete_all
+
+          deleted_count = Models::Message.where(id: locked_ids).delete_all
+
+          { deleted_count: deleted_count, not_deleted_ids: ids - locked_ids }
+        end
+      end
+    end
+  end
+end

data/lib/outboxer/models/exception.rb

@@ -0,0 +1,15 @@
+module Outboxer
+  module Models
+    class Exception < ::ActiveRecord::Base
+      self.table_name = :outboxer_exceptions
+
+      belongs_to :message, class_name: "Outboxer::Models::Message"
+
+      has_many :frames, -> { order(index: :asc) },
+        class_name: "Outboxer::Models::Frame",
+        foreign_key: "exception_id"
+
+      validates :message_id, presence: true
+    end
+  end
+end

data/lib/outboxer/models/frame.rb

@@ -0,0 +1,14 @@
+module Outboxer
+  module Models
+    class Frame < ::ActiveRecord::Base
+      self.table_name = :outboxer_frames
+
+      belongs_to :exception, class_name: 'Outboxer::Models::Exception', foreign_key: 'exception_id'
+      validates :exception_id, presence: true
+
+      validates :index,
+        presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+      validates :text, presence: true
+    end
+  end
+end

data/lib/outboxer/models/message.rb

@@ -0,0 +1,46 @@
+module Outboxer
+  module Models
+    # Represents a message in the outbox.
+    #
+    # @!attribute [r] id
+    #   @return [Integer] The unique id for the message.
+    # @!attribute [r] messageable_id
+    #   @return [Integer] The ID of the associated polymorphic message.
+    # @!attribute [r] messageable_type
+    #   @return [String] The type of the associated polymorphic message.
+    # @!attribute status
+    #   @return [String] The status of the message (see {STATUSES}).
+    # @!attribute [r] created_at
+    #   @return [Time] The timestamp when the record was created.
+    # @!attribute [r] updated_at
+    #   @return [Time] The timestamp when the record was last updated.
+    class Message < ::ActiveRecord::Base
+      self.table_name = :outboxer_messages
+
+      module Status
+        BACKLOGGED = 'backlogged'
+        QUEUED = 'queued'
+        PUBLISHING = 'publishing'
+        FAILED = 'failed'
+      end
+
+      STATUSES = [Status::BACKLOGGED, Status::QUEUED, Status::PUBLISHING, Status::FAILED]
+
+      scope :backlogged, -> { where(status: Status::BACKLOGGED) }
+      scope :queued, -> { where(status: Status::QUEUED) }
+      scope :publishing, -> { where(status: Status::PUBLISHING) }
+      scope :failed, -> { where(status: Status::FAILED) }
+
+      attribute :status, default: -> { Status::BACKLOGGED }
+      validates :status, inclusion: { in: STATUSES }, length: { maximum: 255 }
+
+      belongs_to :messageable, polymorphic: true
+
+      has_many :exceptions,
+        -> { order(created_at: :asc) },
+        foreign_key: 'message_id',
+        class_name: "Outboxer::Models::Exception",
+        dependent: :destroy
+    end
+  end
+end

data/lib/outboxer/models.rb

@@ -0,0 +1,3 @@
+require_relative "models/frame"
+require_relative "models/exception"
+require_relative "models/message"

data/lib/outboxer/railtie.rb

@@ -1,12 +1,10 @@
-require "outboxer"
-require "rails"
-
 module Outboxer
   class Railtie < Rails::Railtie
     railtie_name :outboxer
 
     generators do
-      require_relative "../../generators/outboxer/install_generator"
+      require_relative '../../generators/schema_generator'
+      require_relative '../../generators/message_publisher_generator'
     end
   end
 end

data/lib/outboxer/version.rb

@@ -1,3 +1,3 @@
 module Outboxer
-  VERSION = "0.1.11".freeze
+  VERSION = "1.0.0-beta".freeze
 end