rabbit_messaging 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '081fdf833501fd681239cacf04348b5736d2f445f8b4f995c9cb20f5a4decf2d'
+  data.tar.gz: 566727c03028779e6334f4c89fc2cb2a569dfc7c8dfa92f3399841b610b23f6a
+SHA512:
+  metadata.gz: 118a2d651ce38c6cb60b76464ff1db259865374b0ab8454d9208a7811ee55790796bb8be3cdad0cfbec92750e3a0a97ba36491c9b0e9e697faddbbc3cb7d53aa
+  data.tar.gz: 5e56e561d5077c826d8b1ed5a13dcdf640f14093d5b05fe689fa4d55adc3d9830379e3cafcf289097a56ca78494b4cb33a63ad966456bd8730be1d749007f7dd

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+.ruby-version
+/log/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_gem:
+  rubocop-config-umbrellio: lib/rubocop.yml
+
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.3
+  Include:
+    - lib/**/*.rb
+    - spec/**/*.rb
+    - Gemfile
+    - Rakefile
+    - rabbit_messaging.gemspec
+    - bin/console
+    - environments/*.rb
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+matrix:
+  fast_finish: true
+  include:
+  - rvm: 2.3
+  - rvm: 2.4
+  - rvm: 2.5
+  - rvm: 2.6
+  - rvm: ruby-head
+  allow_failures:
+  - rvm: ruby-head
+sudo: false
+cache: bundler
+before_install: gem install bundler
+script:
+- mkdir log
+- bundle exec rake bundle:audit
+- bundle exec rubocop
+- bundle exec rspec

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Umbrellio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# Rabbit (Rabbit Messaging) ·  [![Gem Version](https://badge.fury.io/rb/rabbit_messaging.svg)](https://badge.fury.io/rb/rabbit_messaging) [![Build Status](https://travis-ci.org/umbrellio/rabbit_messaging.svg?branch=master)](https://travis-ci.org/umbrellio/rabbit_messaging) [![Coverage Status](https://coveralls.io/repos/github/umbrellio/rabbit_messaging/badge.svg?branch=master)](https://coveralls.io/github/umbrellio/rabbit_messaging?branch=master)
+
+Provides client and server support for RabbitMQ
+
+## Installation
+
+```ruby
+gem "rabbit_messaging"
+```
+
+```shell
+$ bundle install
+# --- or ---
+$ gem install "rabbit_messaging"
+```
+
+```ruby
+require "rabbit_messaging"
+```
+
+## Usage
+
+- [Configuration](#configuration)
+- [Client](#client)
+- [Server](#server)
+
+---
+
+### Configuration
+
+- RabbitMQ connection configuration fetched from the `bunny_options` section
+  of `/config/sneakers.yml`
+
+- `Rabbit.config` provides setters for following options:
+
+  * `group_id` (`Symbol`), *required*
+
+    Shared identifier which used to select api. As usual, it should be same as default project_id
+    (I.e. we have project 'support', which runs only one application in production.
+    So on, it's group_id should be :support)
+
+  * `project_id` (`Symbol`), *required*
+
+    Personal identifier which used to select exact service.
+    As usual, it should be same as default project_id with optional stage_id.
+    (I.e. we have project 'support', in production it's project_id is :support,
+    but in staging it uses :support1 and :support2 ids for corresponding stages)
+
+  * `hooks` (`Hash`)
+
+    :before_fork and :after_fork hooks, used same way as in unicorn / puma / que / etc
+
+  * `environment` (one of `:test`, `:development`, `:production`), *default:* `:production`
+
+    Internal environment of gem.
+
+      * `:test` environment stubs publishing and does not suppress errors
+      * `:development` environment auto-creates queues and uses default exchange
+      * `:production` environment enables handlers caching and gets maximum strictness
+
+  * `receiving_job_class_callable` (`Proc`)
+
+    Custom ActiveJob subclass to work with received messages.
+
+  * `exception_notifier` (`Proc`)
+
+    By default, exceptions are reported using `ExceptionNotifier` (see exception_notification gem).
+    You can provide your own notifier like this:
+
+    ```ruby
+      config.exception_notifier = proc { |e| MyCoolNotifier.notify!(e) }
+    ```
+
+---
+
+### Client
+
+```ruby
+Rabbit.publish(
+  routing_key: :support,
+  event: :ping,
+  data: { foo: :bar }, # default is {}
+  exchange_name: 'fanout', # default is fine too
+  confirm_select: true, # setting this to false grants you great speed up and absolutelly no guarantees
+  headers: { "foo" => "bar" }, # custom arguments for routing, default is {}
+)
+```
+
+- This code sends messages via basic_publish with following parameters:
+
+  * `routing_key`: `"support"`
+  * `exchange`: `"group_id.project_id.fanout"` (default is `"group_id.poject_id"`)
+  * `mandatory`: `true` (same as confirm_select)
+
+    It is set to raise error if routing failed
+
+  * `persistent`: `true`
+  * `type`: `"ping"`
+  * `content_type`: `"application/json"` (always)
+  * `app_id`: `"group_id.project_id"`
+
+- Messages are logged to `/log/rabbit.log`
+
+---
+
+### Server
+
+- Server is supposed to run inside a daemon via the `daemons-rails` gem. Server is run with
+`Rabbit::Daemon.run`. `before_fork` and `after_fork` procs in `Rabbit.config` are used
+to teardown and setup external connections between daemon restarts, for example ORM connections
+
+- After the server runs, received messages are handled by `Rabbit::EventHandler` subclasses.
+  Subclasses are selected by following code:
+  ```ruby
+    "rabbit/handler/#{group_id}/#{event}".camelize.constantize
+  ```
+
+  They use powerful `Tainbox` api to handle message data. Project_id also passed to them.
+
+  If you wish so, you can override `initialize(message)`, where message is an object
+  with simple api (@see lib/rabbit/receiving/message.rb)
+
+  Handlers can specify a queue their messages will be put in via a `queue_as` class macro (accepts
+  a string / symbol / block with `|message, arguments|` params)
+
+- Received messages are logged to `/log/sneakers.log`, malformed messages are logged to
+`/log/malformed_messages.log` and deleted from queue
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/umbrellio/rabbit_messaging.
+
+## License
+
+Released under MIT License
+
+## Authors
+
+Team Umbrellio
+
+---
+
+<a href="https://github.com/umbrellio/">
+<img style="float: left;" src="https://umbrellio.github.io/Umbrellio/supported_by_umbrellio.svg"
+alt="Supported by Umbrellio" width="439" height="72">
+</a>

data/Rakefile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "bundler/audit/task"
+require "rspec/core/rake_task"
+require "rubocop"
+require "rubocop-rspec"
+require "rubocop-performance"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  config_path = File.expand_path(File.join(".rubocop.yml"), __dir__)
+
+  t.options = ["--config", config_path]
+  t.requires << "rubocop-rspec"
+  t.requires << "rubocop-performance"
+end
+
+RSpec::Core::RakeTask.new(:rspec)
+Bundler::Audit::Task.new
+
+task default: :rspec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rabbit_messaging"
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/environments/development.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+Bundler.require(:default, :development)
+require "active_job"
+require "active_record"
+
+def Rails.root
+  Pathname.new(__dir__).join("..")
+end
+
+ActiveJob::Base.queue_adapter = :inline
+ActiveJob::Base.logger = Logger.new("/dev/null")
+
+Rabbit.config.project_id = "test_project_id"
+Rabbit.config.group_id = "test_group_id"

data/lib/rabbit.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "tainbox"
+
+require "rabbit/version"
+require "rabbit/daemon"
+require "rabbit/publishing"
+require "rabbit/event_handler"
+
+require "rabbit/extensions/bunny/channel"
+
+module Rabbit
+  InvalidConfig = Class.new(StandardError)
+  MessageNotDelivered = Class.new(StandardError)
+
+  class Config
+    include Tainbox
+
+    attribute :group_id, Symbol
+    attribute :project_id, Symbol
+    attribute :hooks, default: {}
+    attribute :environment, Symbol, default: :production
+    attribute :queue_name_conversion
+    attribute :receiving_job_class_callable
+    attribute :exception_notifier, default: -> { default_exception_notifier }
+
+    def validate!
+      raise InvalidConfig, "mising project_id" unless project_id
+      raise InvalidConfig, "mising group_id" unless group_id
+
+      unless environment.in? %i[test development production]
+        raise "environment should be one of (test, development, production)"
+      end
+    end
+
+    def app_name
+      [group_id, project_id].join(".")
+    end
+
+    alias_method :read_queue, :app_name
+
+    private
+
+    def default_exception_notifier
+      -> (e) { ExceptionNotifier.notify_exception(e) }
+    end
+  end
+
+  extend self
+
+  def config
+    @config ||= Config.new
+    yield(@config) if block_given?
+    @config
+  end
+
+  alias_method :configure, :config
+
+  def publish(message_options)
+    message = Publishing::Message.new(message_options)
+
+    if message.realtime?
+      Publishing.publish(message)
+    else
+      Publishing::Job.set(queue: default_queue_name).perform_later(message.to_hash)
+    end
+  end
+
+  def queue_name(queue, ignore_conversion: false)
+    return queue if ignore_conversion
+    config.queue_name_conversion ? config.queue_name_conversion.call(queue) : queue
+  end
+
+  def default_queue_name(ignore_conversion: false)
+    queue_name(:default, ignore_conversion: ignore_conversion)
+  end
+end

data/lib/rabbit/daemon.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "sneakers"
+require "lamian"
+require "sneakers/runner"
+
+require "rabbit/extensions/bunny/channel"
+require "rabbit/receiving/worker"
+
+module Rabbit
+  module Daemon
+    extend self
+
+    def run
+      Sneakers.configure(
+        connection: connection,
+        env: Rails.env,
+        exchange_type: :direct,
+        exchange: Rabbit.config.app_name,
+        hooks: Rabbit.config.hooks,
+        supervisor: true,
+        daemonize: false,
+        exit_on_detach: true,
+        **config,
+      )
+
+      Sneakers.logger = Logger.new(Rails.root.join("log", "sneakers.log"))
+      Sneakers.logger.level = Logger::DEBUG
+      Lamian.extend_logger(Sneakers.logger)
+
+      Sneakers.server = true
+
+      Rabbit.config.validate!
+      Receiving::Worker.from_queue(Rabbit.config.read_queue)
+
+      Sneakers::Runner.new([Receiving::Worker]).run
+    end
+
+    def config
+      Rails.application.config_for("sneakers").symbolize_keys
+    end
+
+    def connection
+      bunny_config = config.delete(:bunny_options).to_h.symbolize_keys
+      Bunny.new(bunny_config)
+    end
+  end
+end

data/lib/rabbit/event_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "tainbox"
+require "active_support/core_ext/class/attribute"
+
+class Rabbit::EventHandler
+  include Tainbox
+
+  attribute :project_id
+  attr_accessor :data
+  class_attribute :queue
+  class_attribute :ignore_queue_conversion, default: false
+
+  class << self
+    private
+
+    def queue_as(queue = nil, &block)
+      self.queue = queue || block
+    end
+  end
+
+  def initialize(message)
+    self.attributes = message.data
+    self.data       = message.data
+    self.project_id = message.project_id
+  end
+end

data/lib/rabbit/extensions/bunny/channel.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bunny/channel"
+
+class Bunny::Channel
+  module RabbitExtensions
+    def handle_basic_return(*)
+      @unconfirmed_set_mutex.synchronize { @only_acks_received = false } # fails confirm_select
+      super
+    end
+  end
+
+  prepend(RabbitExtensions)
+end

data/lib/rabbit/publishing.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "rabbit/publishing/message"
+
+module Rabbit
+  module Publishing
+    autoload :Job, "rabbit/publishing/job"
+
+    MUTEX = Mutex.new
+
+    extend self
+
+    def publish(message)
+      return unless client
+
+      channel = channel(message.confirm_select?)
+      channel.basic_publish(*message.basic_publish_args)
+
+      if message.confirm_select? && !channel.wait_for_confirms
+        raise MessageNotDelivered, "RabbitMQ message not delivered: #{message}"
+      else
+        log(message)
+      end
+    rescue Timeout::Error
+      raise MessageNotDelivered, <<~MESSAGE
+        Timeout while sending message #{message}. Possible reasons:
+          - #{message.real_exchange_name} exchange is not found
+          - RabbitMQ is extremely high loaded
+      MESSAGE
+    end
+
+    def client
+      MUTEX.synchronize { @client ||= create_client }
+    end
+
+    def channel(confirm)
+      Thread.current[:bunny_channels] ||= {}
+      channel = Thread.current[:bunny_channels][confirm]
+      Thread.current[:bunny_channels][confirm] = create_channel(confirm) unless channel&.open?
+      Thread.current[:bunny_channels][confirm]
+    end
+
+    private
+
+    def create_queue_if_not_exists(channel, message)
+      channel.queue(message.routing_key, durable: true)
+    end
+
+    def create_client
+      return if Rabbit.config.environment == :test
+
+      config = Rails.application.config_for("sneakers") rescue {}
+      config = config["bunny_options"].to_h.symbolize_keys
+
+      begin
+        Bunny.new(config).start
+      rescue
+        raise unless Rabbit.config.environment == :development
+      end
+    end
+
+    def create_channel(confirm)
+      channel = client.create_channel
+      channel.confirm_select if confirm
+      channel
+    end
+
+    def log(message)
+      @logger ||= Logger.new(Rails.root.join("log", "rabbit.log"))
+
+      headers = [
+        message.real_exchange_name, message.routing_key, message.event,
+        message.confirm_select? ? "confirm" : "no-confirm"
+      ]
+
+      @logger.debug "#{headers.join ' / '}: #{message.data}"
+    end
+  end
+end

data/lib/rabbit/publishing/job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rabbit/publishing"
+
+module Rabbit::Publishing
+  class Job < ActiveJob::Base
+    def perform(message)
+      Rabbit::Publishing.publish(Message.new(message))
+    end
+  end
+end

data/lib/rabbit/publishing/message.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "tainbox"
+
+module Rabbit::Publishing
+  class Message
+    include Tainbox
+
+    attribute :routing_key, String
+    attribute :event, String
+    attribute :data, default: {}
+    attribute :exchange_name, default: []
+    attribute :confirm_select, default: true
+    attribute :realtime, default: false
+    attribute :headers
+
+    alias_method :confirm_select?, :confirm_select
+    alias_method :realtime?, :realtime
+
+    def to_hash
+      {
+        **attributes,
+        data: JSON.parse(data.to_json),
+      }
+    end
+
+    def to_s
+      "#{real_exchange_name} -> #{routing_key} -> #{event}"
+    end
+
+    def basic_publish_args
+      Rabbit.config.validate!
+
+      raise "Routing key not specified" unless routing_key
+      raise "Event name not specified" unless event
+
+      options = {
+        mandatory: confirm_select?,
+        persistent: true,
+        type: event,
+        content_type: "application/json",
+        app_id: Rabbit.config.app_name,
+        headers: headers,
+      }
+
+      [JSON.dump(data), real_exchange_name, routing_key.to_s, options]
+    end
+
+    def exchange_name=(names)
+      super(Array(names).map(&:to_s))
+    end
+
+    def real_exchange_name
+      [Rabbit.config.group_id, Rabbit.config.project_id, *exchange_name].join(".")
+    end
+
+    private
+
+    def headers
+      super || {}
+    end
+  end
+end

data/lib/rabbit/receiving.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Rabbit
+  module Receiving
+  end
+end

data/lib/rabbit/receiving/handler_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "rabbit"
+require "rabbit/receiving"
+require "rabbit/event_handler"
+
+module Rabbit::Receiving::HandlerResolver
+  UnsupportedEvent = Class.new(StandardError)
+
+  class << self
+    def handler_for(message)
+      @handler_cache ||= Hash.new do |cache, (group_id, event)|
+        handler = unmemoized_handler_for(group_id, event)
+        cache[[group_id, event]] = handler if Rabbit.config.environment == :production
+        handler
+      end
+
+      @handler_cache[[message.group_id, message.event]]
+    end
+
+    private
+
+    def unmemoized_handler_for(group_id, event)
+      name = "rabbit/handler/#{group_id}/#{event}".camelize
+      handler = name.safe_constantize
+      if handler && handler < Rabbit::EventHandler
+        handler
+      else
+        raise UnsupportedEvent, "#{event.inspect} event from #{group_id.inspect} group is not " \
+                "supported, it requires a #{name.inspect} class inheriting from " \
+                "\"Rabbit::EventHandler\" to be defined"
+      end
+    end
+  end
+end

data/lib/rabbit/receiving/job.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lamian"
+
+require "rabbit"
+require "rabbit/receiving"
+require "rabbit/receiving/message"
+require "rabbit/receiving/handler_resolver"
+require "rabbit/receiving/malformed_message"
+
+class Rabbit::Receiving::Job < ActiveJob::Base
+  def perform(message, arguments)
+    Lamian.run do
+      begin
+        message = Rabbit::Receiving::Message.build(message, arguments)
+        handler = Rabbit::Receiving::HandlerResolver.handler_for(message)
+        handler.new(message).call
+      rescue Rabbit::Receiving::MalformedMessage => error
+        raise if Rabbit.config.environment == :test
+        Rabbit.config.exception_notifier.call(error)
+      end
+    end
+  end
+end

data/lib/rabbit/receiving/malformed_message.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rabbit::Receiving
+  class MalformedMessage < StandardError
+    attr_accessor :message_model, :errors
+
+    def self.logger
+      @logger ||= Logger.new(Rails.root.join("log", "malformed_messages.log"))
+    end
+
+    def self.raise!(message_model, errors, backtrace = caller(1))
+      error = new(message_model, errors)
+      logger.error error.message
+      raise error, error.message, backtrace
+    end
+
+    def initialize(message_model, errors)
+      self.message_model = message_model
+      self.errors = Array(errors)
+
+      errors_list = Array(errors).map { |e| "  - #{e}" }.join("\n")
+
+      super(<<~MESSAGE)
+        Malformed message rejected for following reasons:
+        #{errors_list}
+        Message: #{message_model.attributes.inspect}
+      MESSAGE
+    end
+  end
+end

data/lib/rabbit/receiving/message.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "tainbox"
+
+require "rabbit/receiving/malformed_message"
+
+module Rabbit::Receiving
+  class Message
+    include Tainbox
+
+    attribute :group_id
+    attribute :project_id
+    attribute :event
+    attribute :data
+    attribute :original_message
+
+    attr_accessor :original_message
+
+    def self.build(message, type:, app_id:, **)
+      group_id, project_id = app_id.split(".")
+
+      new(group_id: group_id, project_id: project_id, event: type, data: message)
+    end
+
+    def data=(value)
+      self.original_message = value
+      super(JSON.parse(value).deep_symbolize_keys)
+    rescue JSON::ParserError => error
+      mark_as_malformed!("JSON::ParserError: #{error.message}")
+    end
+
+    def mark_as_malformed!(errors = "Error not specified")
+      MalformedMessage.raise!(self, errors, caller(1))
+    end
+  end
+end

data/lib/rabbit/receiving/worker.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "sneakers"
+
+require "rabbit"
+require "rabbit/receiving/message"
+require "rabbit/receiving/malformed_message"
+require "rabbit/receiving/handler_resolver"
+
+module Rabbit::Receiving
+  autoload :Job, "rabbit/receiving/job"
+
+  class Worker
+    include Sneakers::Worker
+
+    def self.logger
+      @logger ||= Logger.new(Rails.root.join("log", "incoming_rabbit_messages.log"))
+    end
+
+    def work_with_params(message, delivery_info, arguments)
+      message = message.dup.force_encoding("UTF-8")
+      self.class.logger.debug([message, delivery_info, arguments].join(" / "))
+      job_class.set(queue: queue(message, arguments)).perform_later(message, arguments.to_h)
+      ack!
+    rescue => error
+      raise if Rabbit.config.environment == :test
+      Rabbit.config.exception_notifier.call(error)
+      requeue!
+    end
+
+    private
+
+    def queue(message, arguments)
+      message           = Rabbit::Receiving::Message.build(message, arguments)
+      handler           = Rabbit::Receiving::HandlerResolver.handler_for(message)
+      queue_name        = handler.queue
+      ignore_conversion = handler.ignore_queue_conversion
+
+      return Rabbit.default_queue_name(ignore_conversion: ignore_conversion) unless queue_name
+
+      calculated_queue = begin
+        queue_name.is_a?(Proc) ? queue_name.call(message, arguments) : queue_name
+      end
+
+      Rabbit.queue_name(calculated_queue, ignore_conversion: ignore_conversion)
+    rescue
+      Rabbit.default_queue_name
+    end
+
+    def job_class
+      Rabbit.config.receiving_job_class_callable&.call || Job
+    end
+  end
+end

data/lib/rabbit/test_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rabbit::TestHelpers
+  def send_rabbit_message(sender_id, event, data)
+    Rabbit::Receiving::Worker.new.work_with_params(data.to_json, {}, type: event, app_id: sender_id)
+  end
+
+  def expect_rabbit_message(args, strict: true)
+    expectation = if strict
+                    args
+                  else
+                    -> (received_args) { expect(received_args).to match(args) }
+                  end
+    expect(Rabbit).to receive(:publish).with(expectation).once
+  end
+
+  def expect_no_rabbit_messages
+    expect(Rabbit).not_to receive(:publish)
+  end
+end

data/lib/rabbit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rabbit
+  VERSION = "0.6.0"
+end

data/lib/rabbit_messaging.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rabbit"

data/rabbit_messaging.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rabbit/version"
+
+Gem::Specification.new do |spec|
+  spec.required_ruby_version = ">= 2.3.8"
+
+  spec.name    = "rabbit_messaging"
+  spec.version = Rabbit::VERSION
+  spec.authors = ["Umbrellio"]
+  spec.email   = ["oss@umbrellio.biz"]
+
+  spec.summary     = "Rabbit (Rabbit Messaging)"
+  spec.description = "Rabbit (Rabbit Messaging)"
+  spec.homepage    = "https://github.com/umbrellio/rabbit_messaging"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^spec/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "bunny", "~> 2.0"
+  spec.add_runtime_dependency "exception_notification"
+  spec.add_runtime_dependency "lamian"
+  spec.add_runtime_dependency "rails"
+  spec.add_runtime_dependency "sneakers", "~> 2.0"
+  spec.add_runtime_dependency "tainbox"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "bundler-audit"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rubocop-config-umbrellio"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,280 @@
+--- !ruby/object:Gem::Specification
+name: rabbit_messaging
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Umbrellio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: exception_notification
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: lamian
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sneakers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: tainbox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-config-umbrellio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rabbit (Rabbit Messaging)
+email:
+- oss@umbrellio.biz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- environments/development.rb
+- lib/rabbit.rb
+- lib/rabbit/daemon.rb
+- lib/rabbit/event_handler.rb
+- lib/rabbit/extensions/bunny/channel.rb
+- lib/rabbit/publishing.rb
+- lib/rabbit/publishing/job.rb
+- lib/rabbit/publishing/message.rb
+- lib/rabbit/receiving.rb
+- lib/rabbit/receiving/handler_resolver.rb
+- lib/rabbit/receiving/job.rb
+- lib/rabbit/receiving/malformed_message.rb
+- lib/rabbit/receiving/message.rb
+- lib/rabbit/receiving/worker.rb
+- lib/rabbit/test_helpers.rb
+- lib/rabbit/version.rb
+- lib/rabbit_messaging.rb
+- rabbit_messaging.gemspec
+homepage: https://github.com/umbrellio/rabbit_messaging
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Rabbit (Rabbit Messaging)
+test_files: []