bbk-amqp 1.0.0.72904

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e0df2e2301de0e3ec42d3f12ce60b93321e206f0c1263318af185ca33487046
+  data.tar.gz: 371aa962df0e67a3215c551ada7f9538969d6662607ee812ad3cf1eb4ded83c6
+SHA512:
+  metadata.gz: 777ec22b1895c6b86bee77be39764b4b0f66558edaad57c26feb425fce556050fa15a75ef136368b6de79f8261475e40dfb6e2c4717c43481658c5eb4a019652
+  data.tar.gz: e06609cb88278b16c1ce1c9fe341d0694c492915fbdedc1c99e54fa1a3d0aeb9a169bc2e20e8b9ea4f511d6d1a97a3b46bab598d420eb2dacfa4030928f03928

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bbk-amqp.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,154 @@
+PATH
+  remote: .
+  specs:
+    bbk-amqp (1.0.0.72904)
+      activesupport (~> 6.0)
+      bbk-utils (> 1.0.1)
+      bunny (>= 2.19.0)
+      oj
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.4.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    amq-protocol (2.3.2)
+    ansi (1.5.0)
+    ast (2.4.2)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    bbk-app (1.0.0.72899)
+      activesupport
+      bbk-utils (> 1.0.1)
+      timeouter
+    bbk-utils (1.0.1.72735)
+      activesupport (~> 6.0)
+      russian
+    bunny (2.19.0)
+      amq-protocol (~> 2.3, >= 2.3.1)
+      sorted_set (~> 1, >= 1.0.2)
+    bunny-mock (1.7.0)
+      bunny (>= 1.7)
+    byebug (11.1.3)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    concurrent-ruby (1.1.9)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    equalizer (0.0.11)
+    erubis (2.7.0)
+    flay (2.12.1)
+      erubis (~> 2.7.0)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.6.4)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.8)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    ice_nine (0.11.2)
+    kwalify (0.7.2)
+    launchy (2.5.0)
+      addressable (~> 2.7)
+    minitest (5.15.0)
+    oj (3.13.11)
+    parser (3.0.3.2)
+      ast (~> 2.4.1)
+    path_expander (1.1.0)
+    public_suffix (4.0.6)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rbtree (0.4.4)
+    reek (6.0.6)
+      kwalify (~> 0.7.0)
+      parser (~> 3.0.0)
+      rainbow (>= 2.0, < 4.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rspec_junit_formatter (0.5.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    ruby_parser (3.18.1)
+      sexp_processor (~> 4.16)
+    rubycritic (4.6.1)
+      flay (~> 2.8)
+      flog (~> 4.4)
+      launchy (>= 2.0.0)
+      parser (>= 2.6.0)
+      rainbow (~> 3.0)
+      reek (~> 6.0, < 7.0)
+      ruby_parser (~> 3.8)
+      simplecov (>= 0.17.0)
+      tty-which (~> 0.4.0)
+      virtus (~> 1.0)
+    russian (0.6.0)
+      i18n (>= 0.5.0)
+    set (1.0.2)
+    sexp_processor (4.16.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-console (0.9.1)
+      ansi
+      simplecov
+      terminal-table
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    thread_safe (0.3.6)
+    timeouter (0.1.3.38794)
+    tty-which (0.4.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
+    zeitwerk (2.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bbk-amqp!
+  bbk-app (>= 1.0.0)
+  bunny-mock
+  byebug
+  rake
+  rspec
+  rspec_junit_formatter
+  rubycritic
+  simplecov
+  simplecov-console
+
+BUNDLED WITH
+   2.2.33

data/README.md

@@ -0,0 +1,38 @@
+# BBK::AMQP
+
+AMQP interaction classes for BBK stack.
+
+## Installation
+
+Adding to a gem:
+
+```ruby
+# my-cool-gem.gemspec
+
+Gem::Specification.new do |spec|
+  # ...
+  spec.add_dependency "bbk-amqp", "~> 1.0.0"
+  # ...
+end
+```
+
+Or adding to your project:
+
+```ruby
+# Gemfile
+
+gem "bbk-amqp", "~> 1.0.0"
+```
+
+### Supported Ruby versions
+
+* Ruby (MRI) >= 2.5.0
+
+### Tested Ruby versions
+
+* Ruby (MRI) 2.5.x
+* Ruby (MRI) 3.0.x
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bbk/amqp'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)
+

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/lib/bbk/amqp/consumer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module BBK
+  module AMQP
+    class Consumer
+
+      attr_reader :connection, :queue_name, :queue, :options, :logger
+
+      DEFAULT_OPTIONS = {
+        consumer_pool_size:               3,
+        consumer_pool_abort_on_exception: true,
+        prefetch_size:                    10,
+        requeue_on_reject:                false,
+        consumer_tag:                     nil
+      }.freeze
+
+      PROTOCOLS = %w[mq amqp amqps].freeze
+
+      def initialize(connection, queue_name: nil, **options)
+        @connection = connection
+        @channel = options.delete(:channel)
+        @queue = options.delete(:queue)
+
+        if @queue.nil? && queue_name.nil?
+          raise ArgumentError.new('queue_name or queue must be provided!')
+        end
+
+        @queue_name = @queue&.name || queue_name
+
+        @options = DEFAULT_OPTIONS.merge(options)
+
+        logger = @options.fetch(:logger, BBK::AMQP.logger)
+        logger = logger.respond_to?(:tagged) ? logger : ActiveSupport::TaggedLogging.new(logger)
+        @logger = BBK::Utils::ProxyLogger.new(logger, tags: [self.class.to_s, queue_name])
+      end
+
+      # Return protocol list which consumer support
+      def protocols
+        PROTOCOLS
+      end
+
+      # Running non blocking consumer
+      # @param msg_stream [Enumerable] - object with << method
+      def run(msg_stream)
+        @channel ||= @connection.create_channel(nil, options[:consumer_pool_size],
+                                                options[:consumer_pool_abort_on_exception]).tap do |ch|
+          ch.prefetch(options[:prefetch_size])
+        end
+
+        @logger.add_tags "Ch##{@channel.id}"
+
+        @queue ||= @channel.queue(queue_name, passive: true)
+
+        subscribe_opts = {
+          block:        false,
+          manual_ack:   true,
+          consumer_tag: options[:consumer_tag]
+        }.compact
+
+        logger.info 'Starting...'
+        @subscription = queue.subscribe(subscribe_opts) do |delivery_info, metadata, payload|
+          message = Message.new(self, delivery_info, metadata, payload)
+          # logger.debug "Consumed message #{message.headers[:type]}[#{message.headers[:message_id]}] on channel: #{delivery_info.channel&.id}[#{delivery_info.channel&.object_id}] delivery tag: #{message.delivery_info[:delivery_tag].to_i}"
+          logger.debug "Consumed message #{message.headers[:type]}[#{message.headers[:message_id]}] delivery tag: #{message.delivery_info[:delivery_tag].to_i}"
+
+          msg_stream << message
+        end
+        msg_stream
+      end
+
+      # Ack incoming message and not send answer.
+      # @note answer should processing amqp publisher
+      # @param incoming [BBK::AMQP::Message] consumed message from amqp channel
+      # @param answer [BBK::App::Dispatcher::Result] answer message
+      def ack(incoming, *args, answer: nil, **kwargs)
+        # [] - для работы тестов. В реальности вернется объект VersionedDeliveryTag у
+        #  которого to_i (вызывается внутри channel.ack) вернет фактическоe число
+        # logger.debug "Ack message #{incoming.headers[:type]}[#{incoming.headers[:message_id]}] on channel: #{incoming.delivery_info[:channel]&.id}[#{incoming.delivery_info[:channel]&.object_id}] delivery tag: #{incoming.delivery_info[:delivery_tag].to_i}"
+        logger.debug "Ack message #{incoming.headers[:type]}[#{incoming.headers[:message_id]}]  delivery tag: #{incoming.delivery_info[:delivery_tag].to_i}"
+        incoming.delivery_info[:channel].ack incoming.delivery_info[:delivery_tag]
+      end
+
+      # Nack incoming message
+      # @param incoming [BBK::AMQP::Message] nack procesing message
+      def nack(incoming, *args, error: nil, requeue: nil, **_kwargs)
+        logger.debug "Reject message #{incoming.headers[:type]}[#{incoming.headers[:message_id]}] delivery tag: #{incoming.delivery_info[:delivery_tag].to_i}. Error: #{error.inspect}"
+        requeue_message = requeue.nil? ? options[:requeue_on_reject] : requeue
+        incoming.delivery_info[:channel].reject incoming.delivery_info[:delivery_tag],
+                                                requeue_message
+      end
+
+      # stop consuming messages
+      def stop
+        @subscription.tap do |s|
+          return nil unless s
+
+          logger.info 'Stopping...'
+          @subscription = nil
+          s.cancel
+        end
+      end
+
+      # Close consumer - try close amqp channel
+      def close
+        @channel.tap do |c|
+          return nil unless c
+
+          logger.info 'Closing...'
+          @channel = nil
+          c.close
+          logger.info 'Stopped'
+        end
+      end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/domains/by_block.rb

@@ -0,0 +1,24 @@
+module BBK
+  module AMQP
+    module Domains
+      class ByBlock
+
+        attr_reader :name
+
+        def initialize(name, &block)
+          raise ArgumentError.new('no block') unless block_given?
+
+          @name = name
+          @block = block
+        end
+
+        def call(route)
+          @block.call(route)
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/amqp/domains/exchange.rb

@@ -0,0 +1,22 @@
+module BBK
+  module AMQP
+    module Domains
+      class Exchange
+
+
+        attr_reader :name, :exchange
+
+        def initialize(name, exchange)
+          @name = name
+          @exchange = exchange
+        end
+
+        def call(route)
+          BBK::AMQP::RouteInfo.new(exchange, route.routing_key)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/amqp/domains_set.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BBK
+  module AMQP
+    # Store for amqp domains. Domain is pair: domain name and exchange name.
+    class DomainsSet
+
+      def initialize(*domains)
+        @domains = domains.map{|d| [d.name.to_s, d] }.to_h
+      end
+
+      # Get exchange name by domain
+      # @param domain_name [String] domain name
+      # @return [String] exchange name configured for passed domain name
+      def [](domain_name)
+        @domains[domain_name]
+      end
+
+      def add(domain)
+        @domains[domain.name.to_s] = domain
+      end
+
+      alias << add
+
+      # Each method implementation for object iteration
+      def each(&block)
+        @domains.values.each(&block)
+      end
+
+      # Check if store has information about domain
+      # @param domain_name [String] domain name
+      # @return [Boolean] has information about domain
+      def has?(domain_name)
+        @domains.key? domain_name
+      end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/message.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BBK
+  module AMQP
+    # Store information about consumed AMQP message
+    class Message
+
+      attr_reader :consumer, :headers, :body, :payload, :delivery_info, :properties
+
+      def initialize(consumer, delivery_info, properties, body)
+        @consumer = consumer
+        @properties = properties.to_h.with_indifferent_access
+        @body = body
+        amqp_consumer = delivery_info[:consumer]
+        @delivery_info = delivery_info.to_h.merge(
+          message_consumer: consumer,
+          protocols:        consumer.protocols,
+          queue:            amqp_consumer&.queue_name
+        )
+        @headers = @properties.except(:headers).merge(properties[:headers]).with_indifferent_access
+        @payload = begin
+          Oj.load(body).with_indifferent_access
+        rescue StandardError
+          {}.with_indifferent_access
+        end
+      end
+
+      def message_id
+        headers[:message_id]
+      end
+
+      def reply_to
+        headers[:reply_to]
+      end
+
+      def ack(*args, answer: nil, **kwargs)
+        consumer.ack(self, *args, answer: answer, **kwargs)
+      end
+
+      def nack(*args, error: nil, **kwargs)
+        consumer.ack(self, *args, error: error, **kwargs)
+      end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/publisher.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'concurrent'
+
+module BBK
+  module AMQP
+    # Publisher send amqp messages
+    class Publisher
+
+      HEADER_PROP_FIELDS = %i[user_id message_id reply_to correlation_id].freeze
+      PROTOCOLS = %w[mq amqp amqps].freeze
+
+      attr_reader :connection, :domains, :logger, :channel, :ack_map, :sended_messages, :channel
+
+      def initialize(connection, domains, logger: BBK::AMQP.logger)
+        @connection = connection
+        @channel = connection.channel
+        @domains = domains
+
+        logger = logger.respond_to?(:tagged) ? logger : ActiveSupport::TaggedLogging.new(logger)
+        @logger = BBK::Utils::ProxyLogger.new(logger, tags: [self.class.to_s, "Ch##{@channel.id}"])
+
+        @ack_map = Concurrent::Map.new
+        @sended_messages = Concurrent::Map.new
+        @configured_exchanges = Set.new
+        initialize_callbacks
+      end
+
+      # Returned supported protocols list
+      # @return [Array<Symbol>]
+      def protocols
+        PROTOCOLS
+      end
+
+      # Close publisher - try close amqp channel
+      def close
+        @channel.tap do |c|
+          return nil unless c
+
+          @channel = nil
+          c.close
+        end
+      end
+
+      # Publish dispatcher result
+      # @param result [BBK::App::Dispatcher::Result] sended result
+      def publish(result)
+        logger.debug "Try publish dispatcher result #{result.inspect}"
+        route = result.route
+        result_domain = route.domain
+        raise "Unsupported protocol #{route.scheme}" unless PROTOCOLS.include?(route.scheme)
+        raise "Unknown domain #{result_domain}" unless domains.has?(result_domain)
+
+        domain = domains[result_domain]
+        raise ArgumentError.new("Unknown route domain #{resutl_domain}") if domain.nil?
+
+        route_info = domain.call(route)
+        message = result.message
+        publish_message(route_info.routing_key, message, exchange: route_info.exchange)
+      end
+
+      # Publish message
+      # @param routing_key [String] message routing key
+      # @param message [Object] (object with headers and payload method)
+      # @param exchange [Object] exchange for sending message
+      # @param options [Hash] message properties
+      def publish_message(routing_key, message, exchange:, options: {})
+        logger.debug "Try publish message #{message.headers.inspect}"
+        properties = {
+          persistent:  true,
+          mandatory:   true,
+          routing_key: routing_key,
+          headers:     message.headers,
+          user_id:     client_name, # если есть в headers, то на следующей строке будет перетерто
+          **message.headers.select {|k| HEADER_PROP_FIELDS.include? k }.compact
+        }.merge(options).symbolize_keys
+        send_message(exchange, routing_key, message.payload, properties)
+      end
+
+      # Publish raw payload
+      # @param routing_key [String] routing key for sending data
+      # @param exchange [String] exchange name
+      # @param properties [Hash] amqp message properties
+      # @param headers [Messag]
+      def raw_publish(routing_key, exchange:, properties: {}, headers: {}, payload: {})
+        logger.debug "Publish raw message #{headers.inspect}"
+        properties = properties.deep_dup
+        properties[:headers] = properties.fetch(:headers, {}).merge headers
+        properties = properties.merge(headers.select do |k|
+                                        HEADER_PROP_FIELDS.include? k
+                                      end.compact).symbolize_keys
+        send_message(exchange, routing_key, payload, properties)
+      end
+
+      private
+
+        # Initialize amqp callbacks
+        def initialize_callbacks
+          @channel.confirm_select method(:on_confirm).curry(4).call(channel)
+        end
+
+        # Configure on return callback for exchange
+        def configure_exchange(exchange_name)
+          return if @configured_exchanges.include?(exchange_name)
+
+          logger.debug "Configure on_return callback for exchange #{exchange_name}"
+          exchange = channel.exchange(exchange_name, passive: true)
+          exchange.on_return(&method(:on_return).curry(4).call(exchange))
+          @configured_exchanges << exchange_name
+        end
+
+        # Get connection user. If tls connectoin try extract CN from connection tls_cert
+        # @return [String] user name
+        def client_name
+          return connection.user unless connection.ssl?
+
+          @client_name ||= Utils.commonname(connection.transport.tls_certificate_path)
+        end
+
+        def on_return(exchange, basic_return, properties, body)
+          args = { exchange: exchange, basic_return: basic_return, properties: properties,
+body: body }
+          message_id = properties[:message_id]
+          logger.info "Message with message_id #{message_id} returned #{basic_return.inspect}"
+          ack_id, = ack_map.each_pair.find {|_, msg_id| msg_id == message_id }
+
+          sended_messages.delete(ack_id)&.reject(args) if ack_map.delete(ack_id)
+        rescue StandardError => e
+          # TODO: возможно стоит попробовать почистить ack_map и sended_messages
+          logger.error "[CRITICAL]: #{e.inspect}.\n#{e.backtrace.first(10).join("\n")}"
+        end
+
+        def on_confirm(channel, ack_id, flag, neg)
+          logger.debug "Call confirmed callback for message with ack_id #{ack_id} with neg=#{neg}"
+          args = { channel: channel, ack_id: ack_id, flag: flag, neg: neg }
+          if ack_map.delete(ack_id) && (f = sended_messages.delete(ack_id)).present?
+            if neg
+              f.reject(args)
+            else
+              f.fulfill(args)
+            end
+          end
+        rescue StandardError => e
+          # TODO: возможно стоит попробовать почистить ack_map и sended_messages
+          logger.error "[CRITICAL]: #{e.inspect}.\n#{e.backtrace.first(10).join("\n")}"
+        end
+
+        # Send amqp message and save meta information for processing
+        # @param exchange [String] exchange name
+        # @param routing_key [String] message routing key
+        # @param payload [Object] message payload. Converted to json calling to_json method
+        # @param options [Hash] amqp message properties
+        # @return [Concurrent::Promises::ResolvableFuture] future for checking success publishing
+        def send_message(exchange, routing_key, payload, options)
+          configure_exchange(exchange)
+          channel.synchronize do
+            ack_id = channel.next_publish_seq_no
+            options[:message_id] ||= SecureRandom.uuid
+            # в случае укаказанного message_id в качестве числа, on_return вернет message_id в качестве строки
+            ack_map[ack_id] = options[:message_id].to_s
+            future = sended_messages[ack_id] = Concurrent::Promises.resolvable_future
+            logger.debug "Publish message #{options[:message_id]} with ack: #{ack_id} to #{exchange}##{routing_key}"
+            data = if payload.is_a?(String)
+              payload
+            else
+              Oj.generate(payload)
+            end
+            channel.basic_publish(data, exchange, routing_key, options)
+            future
+          end
+        end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/route_info.rb

@@ -0,0 +1,15 @@
+module BBK
+  module AMQP
+    class RouteInfo
+
+      attr_reader :exchange, :routing_key
+
+      def initialize(exchange, routing_key)
+        @exchange = exchange
+        @routing_key = routing_key
+      end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/spec/rabbit_helper.rb

@@ -0,0 +1,68 @@
+require 'bunny'
+require 'fileutils'
+require 'bbk/amqp/utils'
+
+module BBK
+  module AMQP
+    module Spec
+      module RabbitHelper
+
+        cattr_accessor :mq_defaults
+
+        def self.prepare_certs(fixtures_path)
+          FileUtils.mkdir_p File.join(fixtures_path, 'keys')
+
+          cert_path = File.join(fixtures_path, 'keys', 'cert.pem')
+          key_path = File.join(fixtures_path, 'keys', 'key.pem')
+          cacert_path = File.join(fixtures_path, 'keys', 'cacert.pem')
+
+          {
+            'TEST_CLIENT_CERT' => cert_path,
+            'TEST_CLIENT_KEY'  => key_path,
+            'CA_CERT'          => cacert_path
+          }.each_pair do |env, file|
+            File.write(file, ENV[env]) if ENV[env].present?
+          end
+
+          [cert_path, key_path, cacert_path]
+        end
+
+        def self.included(_mod)
+          cert_path, key_path, cacert_path = prepare_certs(File.join($root, 'fixtures'))
+
+          self.mq_defaults = {
+            host:                          ENV['MQ_HOST'] || 'mq',
+            port:                          ENV['MQ_PORT'] || 5671,
+            tls:                           true,
+            tls_cert:                      cert_path,
+            tls_key:                       key_path,
+            tls_ca_certificates:           [cacert_path],
+            verify_peer:                   false,
+            verify_ssl:                    false,
+            verify:                        false,
+            auth_mechanism:                'EXTERNAL',
+            automatically_recover:         false,
+            automatic_recovery:            false,
+            recover_from_connection_close: false,
+            continuation_timeout:          10_000,
+            heartbeat:                     10
+          }
+        end
+
+        def commonname
+          BBK::AMQP::Utils.commonname(mq_defaults[:tls_cert])
+        end
+
+        def mq_connection(options = {})
+          Bunny.new(mq_defaults.merge(options))
+        end
+
+        def mq_pop(queue, timeout = 10)
+          BBK::AMQP::Utils.pop queue, timeout
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/amqp/spec.rb

@@ -0,0 +1,2 @@
+require 'bbk/amqp/spec/rabbit_helper'
+

data/lib/bbk/amqp/utils.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'bunny'
+require 'openssl'
+
+module BBK
+  module AMQP
+    module Utils
+
+      # Try get message from amqp queue
+      # @param queue [Bunny::Queue]
+      # @param timeout [Integer] in seconds for waiting message message in queue
+      # @raise [Timeout::Error] if queue empty in timeout time duration
+      # @return [Array] array with delivery_info, metadata and payload
+      def self.pop(queue, timeout = 10)
+        unblocker = Queue.new
+        consumer = queue.subscribe(block: false) do |delivery_info, metadata, payload|
+          message = [
+            delivery_info,
+            metadata.to_hash.with_indifferent_access,
+            begin
+              Oj.load(payload).with_indifferent_access
+            rescue StandardError
+              payload
+            end
+          ]
+          unblocker << message
+        end
+        Thread.new do
+          sleep timeout
+          unblocker << :timeout
+        end
+        result = unblocker.pop
+        consumer.cancel
+        raise ::Timeout::Error if result == :timeout
+
+        result
+      end
+
+      # Extract CN certificate attribute from certificate path
+      # @param cert_path [String] path to certificate file
+      # @return [String] certificate CN attribute value
+      def self.commonname(cert_path)
+        cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+        cert.subject.to_a.find {|name, _, _| name == 'CN' }[1]
+      end
+
+      # Set default options and create non started connection to amqp
+      # @option options [String] :hosts List of Amqp hosts (default MQ_HOST env variable or mq)
+      # @option options [String] :hostname Amqp host (default MQ_HOST env variable or mq)
+      # @option options [Integer] :port Amqp port (default MQ_PORT env variable or 5671 - default tls port)
+      # @option options [String] :vhost Connected amqp virtual host (default MQ_VHOST env variable or /)
+      # @option options [Boolean] :tls Use tls (default true)
+      # @option options [String] :tls_cert Path to certificate file (default config/keys/cert.pem)
+      # @option options [String] :tls_key Path to key file (default config/keys/key.pem)
+      # @option options [Array] :tls_ca_certificates List to ca certificates (default config/keys/cacert.pem)
+      # @option options [String] :verify Verification option server certificate *
+      # @option options [String] :verify_peer Verification option server certificate *
+      # @option options [String] :verify_ssl Verification option server certificate *
+      # @option options [String] :auth_mechanism Amqp authorization mechanism (default EXTERNAL)
+      # @option options [Boolean] :automatically_recover Allow automatic network failure recovery (default false)
+      # @option options [Boolean] :automatic_recovery Alias for automatically_recover (default false)
+      # @option options [Integer] :recovery_attempts  Limits the number of connection recovery attempts performed by Bunny (default 0, nil - unlimited)
+      # @option options [Boolean] :recover_from_connection_close (default false)
+      # @return [Bunny::Session] non started amqp connection
+      def self.create_connection(options = {})
+        hosts = [options[:hosts] || options[:host] || options[:hostname]].flatten.select(&:present?).uniq
+        hosts = hosts.map{|h| h.split(/[;|]/) }.flatten.select(&:present?).uniq
+
+        options[:hosts] = if hosts.empty?
+          [ENV.fetch('MQ_HOST', 'mq')].split(/[;|]/).flatten.select(&:present?).uniq
+        else
+          hosts
+        end
+
+        options[:port] ||= ENV['MQ_PORT'] || 5671
+        options[:vhost] ||= ENV['MQ_VHOST'] || '/'
+        user = options[:username] || options[:user] || ENV['MQ_USER']
+        options[:username] = options[:user] = user
+
+        # Передаем пустую строку чтобы bunny не использовал пароль по умолчанию guest
+        pwd = options[:password] || options[:pass] || options[:pwd] || ENV['MQ_PASS'] || ''
+        options[:password] = options[:pass] = options[:pwd] = pwd
+
+        options[:tls] = options.fetch(:tls, true)
+        options[:tls_cert] ||= 'config/keys/cert.pem'
+        options[:tls_key] ||= 'config/keys/key.pem'
+        options[:tls_ca_certificates] ||= ['config/keys/cacert.pem']
+
+        options[:verify] =
+          options.fetch(:verify, options.fetch(:verify_peer, options.fetch(:verify_ssl, nil)))
+        options[:verify] = true if options[:verify]
+        options[:verify_peer] = options[:verify]
+        options[:verify_ssl] = options[:verify]
+
+        options[:auth_mechanism] ||= if options[:tls]
+          'EXTERNAL'
+        else
+          'PLAIN'
+        end
+
+        options[:automatically_recover] ||= false
+        options[:automatic_recovery]    ||= false
+        options[:recovery_attempts]     ||= 0
+        options[:recover_attempts] = options[:recovery_attempts]
+        options[:recover_from_connection_close] ||= false
+        Bunny.new(options)
+      end
+
+    end
+  end
+end
+

data/lib/bbk/amqp/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module BBK
+  module AMQP
+
+    VERSION = '1.0.0'
+
+  end
+end
+

data/lib/bbk/amqp.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'oj'
+require 'bbk/utils'
+require 'bbk/amqp/version'
+require 'bbk/amqp/utils'
+require 'bbk/amqp/message'
+require 'bbk/amqp/publisher'
+require 'bbk/amqp/consumer'
+require 'bbk/amqp/route_info'
+require 'bbk/amqp/domains_set'
+require 'bbk/amqp/domains/exchange'
+require 'bbk/amqp/domains/by_block'
+require_relative 'bunny_patch'
+
+
+module BBK
+  module AMQP
+
+    class << self
+
+      attr_accessor :logger
+
+    end
+
+    self.logger = ::BBK::Utils::Logger.default
+
+  end
+end
+

data/lib/bbk/bunny_patch.rb

@@ -0,0 +1,10 @@
+module Bunny
+  class Transport
+
+    def host
+      @opts[:server_name] || @host
+    end
+
+  end
+end
+

data/sig/bbk/amqp/consumer.rbs

@@ -0,0 +1,26 @@
+module BBK
+  module AMQP
+    class Consumer
+      attr_reader connection: untyped
+      attr_reader queue_name: String
+      attr_reader queue: untyped
+      attr_reader options: Hash[String|Symbol, untyped]
+      attr_reader logger: Logger|BBK::Utils::_ProxyObject
+
+      def initialize: (untyped, ?queue_name: String?, **untyped) -> void
+
+      def protocols: () -> Array[String]
+      
+      def run: (BBK::App::Dispatcher::MessageStream) -> void
+
+      def ack: (BBK::App::Dispatcher::_IncomingMessage, *untyped, ?answer: BBK::App::Dispatcher::_Message, **untyped) -> void
+
+      def nack: (BBK::App::Dispatcher::_IncomingMessage, *untyped, ?error: untyped, ?requeue: untyped, **untyped) -> void
+
+      def stop: () -> void
+
+      def close: () -> void
+
+    end
+  end
+end

data/sig/bbk/amqp/domains/by_block.rbs

@@ -0,0 +1,12 @@
+module BBK
+  module AMQP
+    module Domains
+      class ByBlock
+        include _Domain
+
+        def initialize: (String name) {(BBK::App::Dispatcher::Route) -> RouteInfo} -> void
+
+      end
+    end
+  end
+end

data/sig/bbk/amqp/domains/common.rbs

@@ -0,0 +1,10 @@
+module BBK
+  module AMQP
+    module Domains
+      interface _Domain
+        def name: () -> String
+        def call: (BBK::App::Dispatcher::Route) -> RouteInfo
+      end
+    end
+  end
+end

data/sig/bbk/amqp/domains/exchange.rbs

@@ -0,0 +1,14 @@
+module BBK
+  module AMQP
+    module Domains
+      class Exchange
+        include _Domain
+
+        attr_reader exchange: String
+
+        def initialize: (String, String) -> void
+
+      end
+    end
+  end
+end

data/sig/bbk/amqp/domains_set.rbs

@@ -0,0 +1,13 @@
+module BBK
+  module AMQP
+    class DomainsSet
+      def initialize: (*BBK::AMQP::Domains::_Domain) -> void
+
+      def []: (String) -> BBK::AMQP::Domains::_Domain?
+      def add: (BBK::AMQP::Domains::_Domain) -> void
+      def each: () ?{(BBK::AMQP::Domains::_Domain) -> void} -> void
+                  | -> Enumerator[BBK::AMQP::Domains::_Domain, void]
+      def has?: (String) -> bool
+    end
+  end
+end

data/sig/bbk/amqp/message.rbs

@@ -0,0 +1,11 @@
+module BBK
+  module AMQP
+    class Message
+      include BBK::App::Dispatcher::_IncomingMessage
+      # def ack: (*untyped, ?answer: BBK::App::Dispatcher::Result, **untyped) -> void
+      # def nack: (*untyped, ?error: untyped, **untyped) -> void
+
+      def initialize: (BBK::App::Dispatcher::_Consumer, untyped delivery_info, Hash[String|Symbol, untyped] properties, String? body) -> void
+    end
+  end
+end

data/sig/bbk/amqp/publisher.rbs

@@ -0,0 +1,31 @@
+module BBK
+  module AMQP
+    class Publisher
+
+      include BBK::App::Dispatcher::_Publisher
+      # def publish: (BBK::App::Dispatcher::Result) -> untyped
+
+      HEADER_PROP_FIELDS: Array[Symbol]
+
+      attr_reader connection: untyped
+      
+
+      def initialize: (untyped connection, untyped domains, ?logger: _Logger) -> void
+      def protocols: ()-> Array[String]
+
+
+      def publish_message: (String routing_key, BBK::App::Dispatcher::_Message message, exchange: String, ?options: Hash[String|Symbol, untyped]) -> untyped
+  
+      def raw_publish: (String? routing_key, exchange: String, ?properties: Hash[String|Symbol, untyped], ?headers: Hash[String|Symbol, untyped], ?payload: Hash[String|Symbol, untyped]|String?) -> untyped
+
+      private
+
+      def initialize_callbacks: () -> void
+      def configure_exchange: (String? exchange_name) -> void
+      def client_name: () -> String
+      def on_return: (untyped exchange, untyped basic_return, Hash[String|Symbol, untyped] properties, String? body) -> void
+      def on_confirm: (untyped channel, Integer ack_id, untyped flag, bool neg) -> untyped
+      def send_message: (String exchange, String? routing_key, Hash[untyped, untyped]?|String? payload, Hash[String|Symbol, untyped] options) -> void
+    end
+  end
+end

data/sig/bbk/amqp/route_info.rbs

@@ -0,0 +1,10 @@
+module BBK
+  module AMQP
+    class RouteInfo
+      attr_reader exchange: String?
+      attr_reader routing_key: String?
+
+      def initialize: (String? exchange, String? routing_key) -> void
+    end
+  end
+end

data/sig/bbk/amqp/utils.rbs

@@ -0,0 +1,11 @@
+module BBK
+  module AMQP
+    module Utils
+    
+      def self.pop: (untyped queue, ?Integer timeout) -> void
+      def self.commonname: (String cert_path) -> String
+      def self.create_connection: (?Hash[Symbol, untyped] options) -> untyped
+
+    end
+  end
+end

metadata

@@ -0,0 +1,251 @@
+--- !ruby/object:Gem::Specification
+name: bbk-amqp
+version: !ruby/object:Gem::Version
+  version: 1.0.0.72904
+platform: ruby
+authors:
+- Samoylenko Yuri
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: bbk-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  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: bbk-app
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: bunny-mock
+  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: 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: 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_junit_formatter
+  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: rubycritic
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  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 interaction classes for BBK stack
+email:
+- kinnalru@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/console
+- bin/setup
+- lib/bbk/amqp.rb
+- lib/bbk/amqp/consumer.rb
+- lib/bbk/amqp/domains/by_block.rb
+- lib/bbk/amqp/domains/exchange.rb
+- lib/bbk/amqp/domains_set.rb
+- lib/bbk/amqp/message.rb
+- lib/bbk/amqp/publisher.rb
+- lib/bbk/amqp/route_info.rb
+- lib/bbk/amqp/spec.rb
+- lib/bbk/amqp/spec/rabbit_helper.rb
+- lib/bbk/amqp/utils.rb
+- lib/bbk/amqp/version.rb
+- lib/bbk/bunny_patch.rb
+- sig/bbk/amqp/consumer.rbs
+- sig/bbk/amqp/domains/by_block.rbs
+- sig/bbk/amqp/domains/common.rbs
+- sig/bbk/amqp/domains/exchange.rbs
+- sig/bbk/amqp/domains_set.rbs
+- sig/bbk/amqp/message.rbs
+- sig/bbk/amqp/publisher.rbs
+- sig/bbk/amqp/route_info.rbs
+- sig/bbk/amqp/utils.rbs
+homepage:
+licenses: []
+metadata: {}
+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.2.32
+signing_key:
+specification_version: 4
+summary: AMQP interaction classes for BBK stack
+test_files: []