bunny-publisher 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3285bb8050efb8421bb572040231fa85c1b12ee7bcd3cda02af8649101559ce6
+  data.tar.gz: f00f996623c6d099cf405f9555b5cbf437b67ad65aeb34ea2722bc3235492388
+SHA512:
+  metadata.gz: a0148e4c6275e4983b9853a8f12d1e38d1f9eb97c57ed4f4d0adbbb8a071638fa0998544d908ead27841d1b513bc11e284ddd83efe37f9d0d3f1302476f900c2
+  data.tar.gz: 0de5b4d2f9e9cc53c5da44582548b387b7939e8a23d45014bfe7a6868ec98c580c434bc65792790fdfe932ef671667acff2ec0eb2a5c7610e3d2eff014045c5f

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+/.ruby-gemset
+/.ruby-version
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,16 @@
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - "spec/**/*"
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - "spec/**/*"
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+
+Style/EvalWithLocation:
+  Exclude:
+    - "spec/**/*"

data/.travis.yml

@@ -0,0 +1,16 @@
+---
+dist: xenial
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
+env:
+  - BUNNY_VERSION="~> 2.15"
+  - BUNNY_VERSION="2.10.0"
+
+before_install: gem install bundler
+before_script:
+  - ".ci/install_rabbitmq"
+bundler_args: --jobs 3 --retry 3

data/CHANGELOG.md

@@ -0,0 +1 @@
+## Original Release: 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in bunny-publisher.gemspec
+gemspec
+
+gem 'bunny', ENV.fetch('BUNNY_VERSION', '~> 2.15')

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Rustam Sharshenov
+
+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,122 @@
+# BunnyPublisher
+
+[![Build Status](https://travis-ci.com/veeqo/bunny-publisher.svg?branch=master)](https://travis-ci.com/veeqo/bunny-publisher) [![Gem Version](https://badge.fury.io/rb/bunny-publisher.svg)](https://badge.fury.io/rb/bunny-publisher)
+
+Ruby publisher(producer) for [RabbitMQ](https://www.rabbitmq.com/) based on [bunny](https://github.com/ruby-amqp/bunny).
+
+## Why?
+
+Bunny is a great RabbitMQ client that allows to implement both consumers & producers. In order to publish a message it requires only few lines of code:
+```ruby
+conn = Bunny.new
+conn.start
+channel = conn.create_channel
+exchange = channel.exchange('my_exchange')
+exchange.publish('message', routing_key: 'some.key')
+```
+
+But usually more features are requested. Such as:
+1. Multi-thread environment **should re-use AMQP-connection**.
+2. No message **should be lost** if there is no sutable routing at the moment of publishing.
+3. Callbacks support (e.g. for **logging** or **metrics**)
+
+So publisher implementation becomes more complex and hard to maintain. This project aims to reduce amount of boiler-plate code to write. Just use basic publisher with modules for your needs:
+
+1. [`BunnyPublisher::Base`](#basic-usage) - basic publisher with callbacks support. Based on [publisher of Sneakers](https://github.com/jondot/sneakers/blob/ed620b642b447701be490666ee284cf7d60ccf22/lib/sneakers/publisher.rb).
+2. [`BunnyPublisher::Mandatory`](#mandatory-publishing) - module for publisher that uses mandatory option to handle unrouted messages
+3. [`BunnyPublisher::RPC`](#remote-procedure-call-rpc) - module for publisher to support [RPC](https://www.rabbitmq.com/tutorials/tutorial-six-ruby.html)
+
+## Installation
+
+Required ruby version is **2.5**. Add this line to your application's Gemfile:
+
+```ruby
+gem 'bunny-publisher'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bunny-publisher
+
+## Basic usage
+
+Publisher is ready to be used out of the box
+
+```ruby
+# publishes to default exchange, expects "such.easy" queue to exist
+BunnyPublisher.publish 'wow', routing_key: 'such.easy'
+```
+
+Set `RABBITMQ_URL` environment variable to connect to custom host/vhost.
+
+Publisher can also be configured
+
+```ruby
+BunnyPublisher.configure do |c|
+  # custom exchange options
+  c.exchange = 'custom'
+  c.exchange_options = { type: 'fanout' }
+
+  # custom connection (e.g. with ssl configured)
+  c.connection = Bunny.new(something: 'custom')
+
+  # or just custom options for connection
+  c.amqp = ENV['CLOUDAMQP_URL']
+  c.heartbeat = 10
+end
+```
+
+## Mandatory publishing
+
+The publisher also supports [:mandatory](http://rubybunny.info/articles/exchanges.html#publishing_messages_as_mandatory) option to handle unrouted messages. In case of unrouted message publisher:
+
+1. Will create a queue by the name of routing key
+2. Will bind queue to the exchange
+3. Publish message again
+
+Configure publisher to use mandatory option
+
+```ruby
+BunnyPublisher.configure do |c|
+  c.mandatory = true
+
+  # ...
+end
+```
+
+Publish message with new routing key
+
+```ruby
+BunnyPublisher.publish 'wow', routing_key: 'such.reliable' # this will create "such.reliable" queue
+```
+
+You also can set custom settings for queue definition
+
+```ruby
+BunnyPublisher.configure do |c|
+  c.mandatory = true
+
+  c.queue = 'funnel' # if not set, routing_key is used for the name
+  c.queue_options = { durable: true }
+
+  # ...
+end
+```
+
+## Remote Procedure Call RPC
+
+Not implemented yet
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/veeqo/bunny-publisher.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Sponsored by [Veeqo](https://veeqo.com/)

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bunny-publisher.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bunny_publisher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bunny-publisher'
+  spec.version       = BunnyPublisher::VERSION
+  spec.authors       = ['Rustam Sharshenov']
+  spec.email         = ['rustam@sharshenov.com']
+
+  spec.summary       = 'AMQP publisher for RabbitMQ based on Bunny'
+  spec.description   = 'AMQP publisher for RabbitMQ based on Bunny'
+  spec.homepage      = 'https://github.com/veeqo/bunny-publisher'
+  spec.license       = 'MIT'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = spec.homepage
+    spec.metadata['changelog_uri'] = 'https://github.com/veeqo/bunny-publisher/blob/master/CHANGELOG.md'
+  end
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|\.ci)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'bunny', '~> 2.10'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rabbitmq_http_api_client', '~> 1.13'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/bunny/publisher.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bunny_publisher'

data/lib/bunny_publisher.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'bunny'
+require 'bunny_publisher/version'
+require 'bunny_publisher/callbacks'
+require 'bunny_publisher/errors'
+require 'bunny_publisher/base'
+require 'bunny_publisher/mandatory'
+
+module BunnyPublisher
+  class << self
+    def publish(message, options = {})
+      publisher.publish(message, options)
+    end
+
+    def publisher
+      @publisher ||= Base.new
+    end
+
+    def configure
+      require 'ostruct'
+
+      config = OpenStruct.new({})
+
+      yield(config)
+
+      klass = Class.new(Base).tap { |k| k.include(::BunnyPublisher::Mandatory) if config.delete_field(:mandatory) }
+
+      @publisher = klass.new(config.to_h)
+    end
+  end
+end

data/lib/bunny_publisher/base.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module BunnyPublisher
+  # Based on Publisher of Sneakers
+  # https://github.com/jondot/sneakers/blob/ed620b642b447701be490666ee284cf7d60ccf22/lib/sneakers/publisher.rb
+  class Base
+    include Callbacks
+
+    define_callbacks :after_publish, :before_publish, :around_publish
+
+    attr_reader :connection, :channel, :exchange
+
+    def initialize(publish_connection: nil, connection: nil, exchange: nil, exchange_options: {}, **options)
+      @mutex = Mutex.new
+
+      @exchange_name = exchange
+      @exchange_options = exchange_options
+      @options = options
+
+      # Arguments are compatible with Sneakers::CONFIG and if connection given publisher will use it.
+      # But using of same connection for publishing & consumers could cause problems.
+      # https://www.cloudamqp.com/blog/2017-12-29-part1-rabbitmq-best-practice.html#separate-connections-for-publisher-and-consumer
+      # Therefore, publish_connection allows to explicitly make publishers use different connection
+      @connection = publish_connection || connection
+    end
+
+    def publish(message, options = {})
+      ensure_connection!
+
+      run_callback(:before_publish, message, options)
+      result = run_callback(:around_publish, message, options) { exchange.publish(message, options) }
+      run_callback(:after_publish, message, options)
+
+      result
+    end
+
+    def close
+      connection&.close
+    end
+
+    alias stop close
+
+    private
+
+    def ensure_connection!
+      @mutex.synchronize { connect! unless connected? }
+    end
+
+    def connect!
+      @connection ||= build_connection
+      connection.start
+      @channel = connection.create_channel
+      @exchange = build_exchange
+    end
+
+    def build_connection
+      Bunny.new(@options[:amqp] || ENV['RABBITMQ_URL'], @options)
+    end
+
+    def build_exchange
+      return channel.default_exchange if @exchange_name.nil? || @exchange_name == ''
+
+      channel.exchange(@exchange_name, @exchange_options)
+    end
+
+    def connected?
+      @connection&.connected? && channel
+    end
+  end
+end

data/lib/bunny_publisher/callbacks.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module BunnyPublisher
+  # Adds support for callbacks (one per event!)
+  module Callbacks
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_callbacks(*events)
+        events.each do |event|
+          singleton_class.define_method(event) do |method_or_proc|
+            callbacks[event] = method_or_proc
+          end
+        end
+      end
+
+      def callbacks
+        @callbacks ||= {}
+      end
+    end
+
+    private
+
+    def run_callback(event, *args, &block)
+      case (callback = callback_for_event(event))
+      when nil
+        yield if block_given?
+      when Symbol
+        send(callback, self, *args, &block)
+      when Proc
+        callback.call(self, *args, &block)
+      end
+    end
+
+    def callback_for_event(event)
+      self.class.callbacks[event]
+    end
+  end
+end

data/lib/bunny_publisher/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BunnyPublisher
+  class PublishError < StandardError; end
+end

data/lib/bunny_publisher/mandatory.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module BunnyPublisher
+  # Enforces mandatory option for message publishing.
+  # Catches returned message if they are not routed.
+  # Creates queue/binding before re-publishing the same message again.
+  # This publisher DUPLICATES the connection for re-publishing messages!
+  module Mandatory
+    def self.included(klass)
+      klass.define_callbacks :on_message_return,
+                             :after_republish,
+                             :before_republish,
+                             :around_republish
+    end
+
+    attr_reader :queue_name, :queue_options
+
+    def initialize(republish_connection: nil, queue: nil, queue_options: {}, timeout_at_exit: 5, **options)
+      super(options)
+
+      @queue_name = queue
+      @queue_options = queue_options
+
+      @republish_mutex = Mutex.new
+      @republish_connection = republish_connection
+
+      at_exit { wait_for_unrouted_messages_processing(timeout: timeout_at_exit) }
+    end
+
+    def publish(message, options = {})
+      super(message, options.merge(mandatory: true))
+    end
+
+    def close
+      republish_connection&.close
+
+      super
+    end
+
+    alias stop close
+
+    def declare_republish_queue(return_info, _properties, _message)
+      republish_channel.queue(queue_name || return_info.routing_key, queue_options)
+    end
+
+    def declare_republish_queue_binding(queue, return_info, _properties, _message)
+      queue.bind(republish_exchange, routing_key: return_info.routing_key)
+    end
+
+    private
+
+    attr_reader :republish_connection, :republish_channel, :republish_exchange
+
+    def connect!
+      super
+
+      # `on_return` is called within a frameset of amqp connection.
+      # Any interaction within the same connection leads to error. This is why we need extra connection.
+      # https://github.com/ruby-amqp/bunny/blob/7fb05abf36637557f75a69790be78f9cc1cea807/lib/bunny/session.rb#L683
+      if callback_for_event(:on_message_return)
+        exchange.on_return { |*attrs| run_callback(:on_message_return, *attrs) }
+      else
+        exchange.on_return { |*attrs| on_message_return(*attrs) }
+      end
+    end
+
+    def ensure_republish_connection!
+      @republish_mutex.synchronize { connect_for_republish! unless connected_for_republish? }
+    end
+
+    def connected_for_republish?
+      republish_connection&.connected? && republish_channel
+    end
+
+    def connect_for_republish!
+      @republish_connection ||= build_republish_connection
+      republish_connection.start
+      @republish_channel = republish_connection.create_channel
+      @republish_exchange = clone_exchange_for_republish
+    end
+
+    def build_republish_connection
+      Bunny.new(connection.instance_variable_get(:'@opts')) # TODO: find more elegant way to "clone" connection
+    end
+
+    def clone_exchange_for_republish
+      republish_channel.default_exchange if exchange.name == ''
+
+      republish_channel.exchange exchange.name,
+                                 exchange.instance_variable_get(:'@options').merge(type: exchange.type)
+    end
+
+    def on_message_return(return_info, properties, message)
+      @unrouted_message = true
+
+      ensure_message_is_unrouted!(return_info, properties, message)
+
+      setup_queue_for_republish(return_info, properties, message)
+
+      run_callback(:before_republish, return_info, properties, message)
+      result = run_callback(:around_republish, return_info, properties, message) do
+        republish_exchange.publish(message, properties.to_h.merge(routing_key: return_info.routing_key))
+      end
+      run_callback(:after_republish, return_info, properties, message)
+
+      @unrouted_message = false
+      result
+    end
+
+    def setup_queue_for_republish(return_info, properties, message)
+      ensure_republish_connection!
+
+      queue = declare_republish_queue(return_info, properties, message)
+
+      # default exchange already has bindings with queues
+      declare_republish_queue_binding(queue, return_info, properties, message) unless republish_exchange.name == ''
+
+      republish_channel.deregister_queue(queue) # we are not going to work with this queue in this channel
+    end
+
+    def ensure_message_is_unrouted!(return_info, properties, message)
+      return if return_info.reply_text == 'NO_ROUTE'
+
+      raise BunnyPublisher::PublishError, message: message,
+                                          return_info: return_info,
+                                          properties: properties
+    end
+
+    # TODO: introduce more reliable way to wait for handling of unrouted messages at exit
+    def wait_for_unrouted_messages_processing(timeout:)
+      sleep(0.05) # gives exchange some time to receive retuned message
+
+      return unless @unrouted_message
+
+      puts("Waiting up to #{timeout} seconds for unrouted messages handling")
+
+      Timeout.timeout(timeout) { sleep 0.01 while @unrouted_message }
+    rescue Timeout::Error
+      puts('Some unrouted messages are lost on process exit!')
+    end
+  end
+end

data/lib/bunny_publisher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BunnyPublisher
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: bunny-publisher
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rustam Sharshenov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !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: pry-byebug
+  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: rabbitmq_http_api_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !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'
+description: AMQP publisher for RabbitMQ based on Bunny
+email:
+- rustam@sharshenov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bunny-publisher.gemspec
+- lib/bunny/publisher.rb
+- lib/bunny_publisher.rb
+- lib/bunny_publisher/base.rb
+- lib/bunny_publisher/callbacks.rb
+- lib/bunny_publisher/errors.rb
+- lib/bunny_publisher/mandatory.rb
+- lib/bunny_publisher/version.rb
+homepage: https://github.com/veeqo/bunny-publisher
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/veeqo/bunny-publisher
+  source_code_uri: https://github.com/veeqo/bunny-publisher
+  changelog_uri: https://github.com/veeqo/bunny-publisher/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: AMQP publisher for RabbitMQ based on Bunny
+test_files: []