strum-esb 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 360c4b7cd86f34d2dd3628104474c6948cb926b852c493880b931d0f7a1730e6
-  data.tar.gz: 963fc92e530b52200a58e205247ded0728e1247aa8c865c69f3aa5d56fe729fa
+  metadata.gz: 100cac09566f7c972a3ea3cb7005fc3c57ecc20cc7cb4e159b43dcf4b5d9bc24
+  data.tar.gz: dd290413c6ae5f8cc50659a487bc656500c04cd27d289cf13f10eaea14e90343
 SHA512:
-  metadata.gz: 9ffa2333d5dbbd263b32c7944acbfe2f82aa9233c8f7e6f2337f2444f134fb88b33ec260e377c1d4126609ad1194f62a24acce30a0cdc34f919f027da62db9a1
-  data.tar.gz: 740715b0c16c4c2f270f94fd2fca43aea88194f9c0352860b31fdb74758ffafa92cbaefb755f783b6de540473779d48a81a4b45ed50f8bb6270e7e350d3c8126
+  metadata.gz: c1a9a87ba8f0207f0de46d08f19229835e29ab844f2053f38a0eb484efc191460d83a6d5e87421d1d4df09152138e753f93705035b4866c6f0ff502b2cffdadf
+  data.tar.gz: b3f3d16931dd745a09a7cfbe938b9170c8e4efb4bf511f7de796595ad43ec683cf72c4865cbfe838ee91005b5df1431b32fa12a09fa5426a176a2f99ede62bc3

data/.gitlab-ci.yml

@@ -0,0 +1,3 @@
+include:
+  - project: 'strum-rb/ci-cd'
+    file: '/strum-rb/.gitlab-ci.yml'

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   TargetRubyVersion: 2.6
+  NewCops: enable
 
 # Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
 Style/HashSyntax:

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+
+# Changelog
+All notable changes to this project will be documented in this file.
+
+## [0.1.1] - 2021-06-01
+### Added
+- `pre_publish_hooks` to configuration by [@Samuron]
+
+### Fixed
+- bindings for `notice` by [@anton.klyzhka].
+- custom handlers for resource name with `-` by [@anton.klyzhka].
+
+### Changed
+- return `chain` to header and payload for back compatibility by [@anton.klyzhka].

data/Gemfile

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in strum-esb.gemspec
 gemspec
 
 gem "bundler", "~> 2.1.4"
-gem "rake", "~> 12"
 gem "rspec", "~> 3"
-gem "rubocop", "~> 0.62.0"
+gem "rubocop", "~> 1.15"
+gem "rubocop-rspec", "~> 2.3.0"
 
 gem "debase", "~> 0.2.4"
-gem "ruby-debug-ide", "~> 0.7.0"
+gem "ruby-debug-ide", "~> 0.7.2"
+

data/Gemfile.lock

@@ -1,59 +1,74 @@
 PATH
   remote: .
   specs:
-    strum-esb (0.0.1)
+    strum-esb (0.2.0)
       bunny (~> 2.15)
       connection_pool (~> 2.2.2)
+      dry-configurable (~> 0.12.1)
       json (~> 2.3)
       sneakers (~> 2.12)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    amq-protocol (2.3.1)
-    ast (2.4.0)
-    bunny (2.15.0)
+    amq-protocol (2.3.2)
+    ast (2.4.2)
+    bunny (2.19.0)
       amq-protocol (~> 2.3, >= 2.3.1)
-    concurrent-ruby (1.1.6)
-    connection_pool (2.2.2)
+      sorted_set (~> 1, >= 1.0.2)
+    concurrent-ruby (1.1.9)
+    connection_pool (2.2.5)
     debase (0.2.4.1)
       debase-ruby_core_source (>= 0.10.2)
-    debase-ruby_core_source (0.10.9)
-    diff-lcs (1.3)
-    jaro_winkler (1.5.4)
-    json (2.3.0)
-    parallel (1.19.1)
-    parser (2.7.1.1)
-      ast (~> 2.4.0)
-    powerpack (0.1.2)
+    debase-ruby_core_source (0.10.12)
+    diff-lcs (1.4.4)
+    dry-configurable (0.12.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5.0)
+    dry-core (0.7.1)
+      concurrent-ruby (~> 1.0)
+    json (2.5.1)
+    parallel (1.20.1)
+    parser (3.0.1.1)
+      ast (~> 2.4.1)
     rainbow (3.0.0)
     rake (12.3.3)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.1)
+    rbtree (0.4.4)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    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.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
-    rubocop (0.62.0)
-      jaro_winkler (~> 1.5.1)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rubocop (1.15.0)
       parallel (~> 1.10)
-      parser (>= 2.5, != 2.5.1.1)
-      powerpack (~> 0.1)
+      parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.5.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.4.0)
-    ruby-debug-ide (0.7.0)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.6.0)
+      parser (>= 3.0.1.1)
+    rubocop-rspec (2.3.0)
+      rubocop (~> 1.0)
+      rubocop-ast (>= 1.1.0)
+    ruby-debug-ide (0.7.2)
       rake (>= 0.8.1)
-    ruby-progressbar (1.10.1)
+    ruby-progressbar (1.11.0)
     serverengine (2.1.1)
       sigdump (~> 0.2.2)
+    set (1.0.1)
     sigdump (0.2.4)
     sneakers (2.12.0)
       bunny (~> 2.14)
@@ -61,8 +76,11 @@ GEM
       rake (~> 12.3)
       serverengine (~> 2.1.0)
       thor
-    thor (1.0.1)
-    unicode-display_width (1.4.1)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    thor (1.1.0)
+    unicode-display_width (2.0.0)
 
 PLATFORMS
   ruby
@@ -70,10 +88,10 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 2.1.4)
   debase (~> 0.2.4)
-  rake (~> 12)
   rspec (~> 3)
-  rubocop (~> 0.62.0)
-  ruby-debug-ide (~> 0.7.0)
+  rubocop (~> 1.15)
+  rubocop-rspec (~> 2.3.0)
+  ruby-debug-ide (~> 0.7.2)
   strum-esb!
 
 BUNDLED WITH

data/README.md

@@ -1,8 +1,6 @@
 # Strum::Esb
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/strum/esb`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Useful sender RabbitMQ messages and handle them
 
 ## Installation
 
@@ -22,7 +20,80 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Configuration
+
+Exchanges can be customized by each message type:
+```ruby
+Strum::Esb.config.info_exchange = `demo.info`
+Strum::Esb.config.event_exchange = `demo.events`
+Strum::Esb.config.action_exchange = `demo.actions`
+Strum::Esb.config.notice_exchange = `demo.notice`
+```
+
+Before publish hooks allow you to configure custom code that will be able to modify properties of the message that will be published or execute any arbitrary logic
+```ruby
+Strum::Esb.config.before_publish_hooks << ->(body, properties) { properties[:correlation_id] = "hello world" }
+```
+
+Before handler hooks allow you to inspect raw data before any processing has strated:
+```ruby
+Strum::Esb.config.before_handler_hooks << ->(deserialized_msg, delivery_info, metadata) do 
+  puts "We don't even know if msg is valid JSON, this is some text from RabbitMQ"
+  puts deserialized_msg
+end
+```
+
+After handler hook allows you to have insight on how handler was executed:
+```ruby
+Strum::Esb.config.after_handler_hooks << ->(deserialized_msg, delivery_info, metadata, payload, error) do 
+  puts "Message was deserialized succesfully" if payload
+  puts "Error occured" if error
+end
+```
+
+
+### Sending message:
+
+```ruby
+Strum::Esb::Action.call(`payload`, `action`, `resource`)
+```
+
+```ruby
+Strum::Esb::Event.success(`payload`, `resource`, `*events`)
+Strum::Esb::Event.failure(`payload`, `resource`, `*events`)
+```
+
+```ruby
+Strum::Esb::Info.call(`payload`, `resource`)
+```
+
+```ruby
+Strum::Esb::Notice.call(`payload`, `notice`)
+Strum::Esb::Notice.call(`payload`, `notice`, `resource`)
+```
+
+### Handling message:
+
+```ruby
+require "strum/esb"
+
+module Queues
+  class Resource
+    include Strum::Esb::Handler
+
+    from_queue "resource-queue",
+               bindings: {
+                 events: %w[user/create user/update],
+                 
+               }
+
+    def handler(payload)
+      # code here ...
+    end
+  end
+end
+```
+
 
 ## Development
 
@@ -32,5 +103,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/strum-esb.
+Bug reports and pull requests are welcome on GitHub at https://code.qpard.com/srtrum/strum-esb.
 

data/Rakefile

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

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "strum/esb"
@@ -10,11 +11,11 @@ require "strum/esb"
 # require "pry"
 # Pry.start
 
-Strum::Esb::Message.rabbit_connection ||= begin
-  rabbit_connection = Bunny.new
-  rabbit_connection.start
-  rabbit_connection
-end
+Strum::Esb.config.exchange = "demo.general"
+Strum::Esb.config.info_exchange = "demo.info"
+Strum::Esb.config.event_exchange = "demo.events"
+Strum::Esb.config.action_exchange = "demo.actions"
+Strum::Esb.config.notice_exchange = "demo.notice"
 
 require "irb"
 IRB.start(__FILE__)

data/lib/strum/esb/action.rb

@@ -7,8 +7,8 @@ module Strum
     # Action message
     class Action < Message
       class << self
-        def call(payload, action, resource, exchange: "strum.actions", chain: Thread.current[:chain])
-          publish(headers: { resource: resource, action: action }, payload: payload, exchange: exchange, chain: chain)
+        def call(payload, action, resource, exchange: Strum::Esb.config.action_exchange, **opts)
+          publish(headers: { resource: resource, action: action }, payload: payload, exchange: exchange, **opts)
         end
       end
     end

data/lib/strum/esb/event.rb

@@ -7,13 +7,16 @@ module Strum
     # Event message
     class Event < Message
       class << self
-        def call(payload, resource, event, state, exchange:, chain:)
-          publish(headers: { resource: resource, event: event, state: state }, payload: payload, exchange: exchange, chain: chain)
-        end
-
         %i[success failure].each do |method_name|
-          define_method method_name do |payload, resource, *events, exchange: "strum.events", chain: Thread.current[:chain]|
-            events.each { |event| call(payload, resource, event, method_name, exchange: exchange, chain: chain) }
+          define_method method_name do |payload, resource, event, exchange: Strum::Esb.config.event_exchange, **opts|
+            publish(headers: {
+                      resource: resource,
+                      event: event,
+                      state: method_name
+                    },
+                    payload: payload,
+                    exchange: exchange,
+                    **opts)
           end
         end
       end

data/lib/strum/esb/functions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Strum
+  module Esb
+    class Functions
+      class << self
+        def action_explain(source)
+          exchange, resource_action = source.include?(":") ? source.split(":") : [Strum::Esb.config.action_exchange, source]
+          action, resource = resource_action.split("/")
+          [exchange, action, resource]
+        end
+
+        def event_explain(source)
+          exchange, resource_event = source.include?(":") ? source.split(":") : [Strum::Esb.config.event_exchange, source]
+          resource, event, state = resource_event.split("/")
+          [exchange, resource, event, state || "success"]
+        end
+
+        def notice_explain(source)
+          exchange, resource_notice = source.include?(":") ? source.split(":") : [Strum::Esb.config.notice_exchange, source]
+          resource, notice  = resource_notice.split("/")
+          [exchange, resource, notice]
+        end
+
+        def info_explain(source)
+          source.include?(":") ? source.split(":") : [Strum::Esb.config.info_exchange, source]
+        end
+      end
+    end
+  end
+end

data/lib/strum/esb/handler.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "strum/esb/functions"
 
 module Strum
   module Esb
@@ -10,11 +11,31 @@ module Strum
         base.class_eval do
           include Sneakers::Worker
         end
+        base.extend ClassMethods
       end
 
-      def work_with_params(deserialized_msg, _delivery_info, metadata)
-        notice_data = JSON.parse(deserialized_msg)
+      module ClassMethods
+        def bind_to(queue, message_type, message_binding, handler = nil)
+          bindings ||= (queue_opts && queue_opts[:bindings]) || {}
+          bindings[message_type] ||= []
+          bindings[message_type] << message_binding
+          from_queue queue, bindings: bindings
+          _, *msg = Strum::Esb::Functions.public_send("#{message_type}_explain", message_binding)
+          @handlers ||= {}
+          params = msg.map{ |param| param&.to_s.gsub(/[^a-zA-Z0-9]/, "_")&.downcase }
+          handler_key = ([message_type] + params).join("-")
+          @handlers[handler_key] = handler.to_s if handler
+        end
+
+        def handlers
+          @handlers || {}
+        end
+      end
+
+      def work_with_params(deserialized_msg, delivery_info, metadata)
+        Strum::Esb.config.before_handler_hooks.each { |hook| hook.call(deserialized_msg, delivery_info, metadata) }
 
+        payload = JSON.parse(deserialized_msg)
         snake_case_modify = ->(string) { string.nil? ? nil : string&.to_s.gsub(/[^a-zA-Z0-9]/, "_")&.downcase }
         parse_header = ->(string) { metadata[:headers] && metadata[:headers][string] }
         header = parse_header >> snake_case_modify
@@ -24,47 +45,87 @@ module Strum
         event = header.call("event")
         state = header.call("state")
         info = header.call("info")
-        chain = header.call("chain")
         notice = header.call("notice")
-        Thread.current[:chain] = chain
+        Thread.current[:chain] = header.call("chain")
+        Thread.current[:pipeline] = header.call("pipeline")
+        Thread.current[:pipeline_id] = header.call("pipeline-id")
+
+        after_headers_hook
 
         methods_names = if action
-                          %W[action_#{action}_#{resource} action_handler]
+                          action_handler_methods(action, resource)
                         elsif event
-                          result = %W[event_#{resource}_#{event}_#{state}]
-                          result << "event_#{resource}_#{event}" if state.eql?("success")
-                          result << "event_handler"
-                          result
+                          event_handler_methods(resource, event, state)
                         elsif info
-                          %W[info_#{info} info_handler]
+                          info_handler_methods(info)
                         elsif notice
-                          result = []
-                          result << "notice_#{resource}_#{notice}" if resource
-                          result << "notice_#{notice}"
-                          result << "notice_handler"
-                          result
-        end
+                          notice_handler_methods(resource, notice)
+                        end
 
         method_name = ([*methods_names] << "handler").find { |n| respond_to?(n, include_all: true) }
 
         unless method_name
-          logger.debug "Handler not found. Message rejected #{metadata[:headers]} with payload #{notice_data}"
+          logger.error "Handler not found. Message rejected #{metadata[:headers]} with payload #{payload}"
           return reject!
         end
 
+        error = nil
         method_params = method(method_name)
                         .parameters
                         .map { |param| _, param_name = param; param_name }
-                        .then { |m| m & %I[action resource event state chain info] }
+                        .then { |m| m & %I[action resource event state info chain] }
         handler_params = method_params.each_with_object({}) { |i, res| res[i] = eval(i.to_s); }
-        logger.debug("Handler #{method_name} found. Payload: #{notice_data}")
-        handler_params.count.positive? ? send(method_name, notice_data, handler_params) : send(method_name, notice_data)
-        logger.debug("Handler #{method_name} executed")
+        logger.info("Handler #{method_name} found. Payload: #{payload}")
+        handler_params.count.positive? ? send(method_name, payload, handler_params) : send(method_name, payload)
+        logger.info("Handler #{method_name} executed")
         ack!
       rescue StandardError => e
+        error = e
         logger.error e
         reject!
+      ensure 
+        Strum::Esb.config.after_handler_hooks.each { |hook| hook.call(deserialized_msg, delivery_info, metadata, payload, error) }
       end
+
+      def after_headers_hook; end
+
+      private
+
+        def action_handler_methods(action, resource)
+          if (custom_handler = self.class.handlers[["action", action, resource].join("-")])
+            %W[#{custom_handler} action_#{action}_#{resource} action_handler]
+          else
+            %W[action_#{action}_#{resource} action_handler]
+          end
+        end
+
+        def event_handler_methods(resource, event, state)
+          result = []
+          custom_handler = self.class.handlers[["event", resource, event, state].join("-")]
+          result << custom_handler if custom_handler
+          result << "event_#{resource}_#{event}_#{state}"
+          result << "event_#{resource}_#{event}" if state.eql?("success")
+          result << "event_handler"
+          result
+        end
+
+        def info_handler_methods(info)
+          if (custom_handler = self.class.handlers[["info", info].join("-")])
+            %W[#{custom_handler} info_#{info} info_handler]
+          else
+            %W[info_#{info} info_handler]
+          end
+        end
+
+        def notice_handler_methods(resource, notice)
+          custom_handler = self.class.handlers[["notice", resource, notice].join("-")]
+          result = []
+          result << custom_handler if custom_handler
+          result << "notice_#{resource}_#{notice}" if resource
+          result << "notice_#{notice}"
+          result << "notice_handler"
+          result
+        end
     end
   end
-end
+end

data/lib/strum/esb/info.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "message"
+require "strum/esb/message"
 
 module Strum
   module Esb
     # Action message
     class Info < Message
       class << self
-        def call(payload, resource, exchange: "strum.info", chain: Thread.current[:chain])
-          publish(headers: { info: resource }, payload: payload, exchange: exchange, chain: chain)
+        def call(payload, resource, exchange: Strum::Esb.config.info_exchange, **opts)
+          publish(headers: { info: resource }, payload: payload, exchange: exchange, **opts)
         end
       end
     end

data/lib/strum/esb/message.rb

@@ -5,25 +5,26 @@ module Strum
     # Strum Message
     class Message
       class << self
-        attr_accessor :rabbit_connection
+        def publish(exchange:, headers:, payload:)
+          rabbit_exchange ||= Strum::Esb.config.rabbit_channel_pool.with { |rabbit_channel| rabbit_channel.headers(exchange, durable: true) }
+          properties = {
+            headers: headers,
+            content_type: "application/json"
+          }
 
-        def publish(exchange:, headers:, payload:, chain:)
-          rabbit_exchange ||= Strum::Esb::Message.rabbit_channel.headers(exchange, durable: true)
-          if chain
+          Strum::Esb.config.before_publish_hooks.each { |hook| hook.call(payload, properties) }
+
+          properties[:headers] = {} unless properties[:headers].is_a?(Hash)
+          properties[:headers]["pipeline"] ||= Thread.current[:pipeline] if Thread.current[:pipeline]
+          properties[:headers]["pipeline-id"] ||= Thread.current[:pipeline_id] if Thread.current[:pipeline_id]
+          if (chain = Thread.current[:chain])
             payload["chain"] ||= chain
             headers["chain"] ||= chain
           end
-          rabbit_exchange.publish(payload.to_json, headers: headers, content_type: "application/json")
-        end
-
-        def rabbit_channel
-          @rabbit_channel ||= begin
-            raise "Strum::Esb::Message.rabbit_connection must be setup" unless rabbit_connection
-            rabbit_connection.create_channel
-          end
+          
+          rabbit_exchange.publish(payload.to_json, **properties)
         end
       end
     end
   end
 end
-

data/lib/strum/esb/notice.rb

@@ -7,10 +7,10 @@ module Strum
     # Notice message
     class Notice < Message
       class << self
-        def call(payload, notice, resource = nil, exchange: "strum.notice", chain: Thread.current[:chain])
+        def call(payload, notice, resource = nil, exchange: Strum::Esb.config.notice_exchange, **opts)
           headers = { notice: notice }
           headers[:resource] = resource if resource
-          publish(headers: headers, payload: payload, exchange: exchange, chain: chain)
+          publish(headers: headers, payload: payload, exchange: exchange, **opts)
         end
       end
     end

data/lib/strum/esb/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Strum
   module Esb
-    VERSION = "0.0.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/strum/esb.rb

@@ -1,36 +1,61 @@
+# frozen_string_literal: true
+
 require "strum/esb/version"
 
 require "json"
 require "bunny"
 require "sneakers"
-require_relative "patch/sneakers/queue_patch"
-require_relative "esb/handler"
-require_relative "esb/message"
-require_relative "esb/action"
-require_relative "esb/event"
-require_relative "esb/notice"
-require_relative "esb/info"
+require "connection_pool"
+require "etc"
+require "strum/patch/sneakers/queue_patch"
+require "strum/esb/handler"
+require "strum/esb/message"
+require "strum/esb/action"
+require "strum/esb/event"
+require "strum/esb/notice"
+require "strum/esb/info"
+require "dry/configurable"
 
 module Strum
   module Esb
+    extend Dry::Configurable
+
+    setting :sneakers_workers, ENV.fetch("SNEAKERS_WORKERS", 1)
+    setting :exchange, "strum.general"
+    setting :info_exchange, "strum.info"
+    setting :event_exchange, "strum.events"
+    setting :action_exchange, "strum.actions"
+    setting :notice_exchange, "strum.notice"
+    setting :rabbit_channel_pool, begin
+                                    ConnectionPool.new(size: 5, timeout: 5) do
+                                      rabbit_connection = Bunny.new
+                                      rabbit_connection.start
+                                      rabbit_connection.create_channel
+                                    end
+                                  end
+    setting :before_fork_hooks, []
+    setting :after_fork_hooks, []
+    setting :before_publish_hooks, []
+    setting :before_handler_hooks, []
+    setting :after_handler_hooks, []
+
+    Strum::Esb.config.before_fork_hooks << proc { DB.disconnect } if defined?(DB)
+
+    Strum::Esb.config.after_fork_hooks << proc do
+    end
+
     class Error < StandardError; end
 
     Sneakers.configure(
-        log: STDOUT,
-        hooks: {
-            before_fork: lambda { DB.disconnect if defined?(DB) },
-            after_fork: lambda do
-              Strum::Esb::Message.rabbit_connection ||= begin
-                rabbit_connection = Bunny.new
-                rabbit_connection.start
-                rabbit_connection
-              end
-            end
-        },
-        exchange: "strum.general",
-        exchange_type: "headers"
+      log: $stdout,
+      workers: Strum::Esb.config.sneakers_workers,
+      hooks: {
+        before_fork: -> { Strum::Esb.config.before_fork_hooks.each(&:call) },
+        after_fork: -> { Strum::Esb.config.after_fork_hooks.each(&:call) }
+      },
+      exchange: Strum::Esb.config.exchange,
+      exchange_type: "headers"
     )
     Sneakers.logger.level = Logger::INFO
-
   end
 end

data/lib/strum/patch/sneakers/queue_patch.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "sneakers/queue"
+require "strum/esb/functions"
 
 module QueuePatch
   def subscribe(worker)
     if @opts[:bindings]
-      qiwa_subscribe(worker)
+      strum_subscribe(worker)
     elsif @opts[:header_bindings]
       header_subscribe(worker)
     else
@@ -17,93 +18,89 @@ module QueuePatch
   #   actions: "get/account",
   #   events: %w[account/update account/delete],
   #   infos: "account"
+  #   pipeline: {
+  #     name: "pipeline-name",
+  #     actions: "get/account",
+  #     events: %w[account/update account/delete],
+  #     infos: "account"
+  #   }
   # }
-  def qiwa_subscribe(worker)
+
+  def strum_subscribe(worker)
     @opts[:header_bindings] = []
     actions_subscribes([*(@opts[:bindings][:actions] || @opts[:bindings][:action])])
     events_subscribes([*(@opts[:bindings][:events] || @opts[:bindings][:event])])
     infos_subscribes([*(@opts[:bindings][:infos] || @opts[:bindings][:info])])
     notices_subscribes([*(@opts[:bindings][:notices] || @opts[:bindings][:notice])])
+    pipeline_subscribes(@opts[:bindings][:pipeline] || @opts[:bindings][:pipelines])
     header_subscribe(worker)
   end
 
-  def actions_subscribes(actions)
-    actions.each do |_action|
-      exchange, resource_action = _action.split(":")
-      if resource_action.nil?
-        resource_action = exchange
-        exchange = "strum.actions"
-      end
-      raise StandardError "binding format must be a `exchange:action/resource`" unless exchange && resource_action
+  def pipeline_subscribes(pipelines)
+    return if pipelines.nil?
+
+    actions_subscribes([*(pipelines[:actions] || pipelines[:action])], pipeline: pipelines[:name])
+    events_subscribes([*(pipelines[:events] || pipelines[:event])], pipeline: pipelines[:name])
+    infos_subscribes([*(pipelines[:infos] || pipelines[:info])], pipeline: pipelines[:name])
+    notices_subscribes([*(pipelines[:notices] || pipelines[:notice])], pipeline: pipelines[:name])
+  end
 
-      action, resource = resource_action.split("/")
-      raise StandardError "binding format must be a `exchange:action/resource`" unless resource && action
+  def actions_subscribes(actions, **custom_headers)
+    actions.each do |_action|
+      exchange, action, resource = Strum::Esb::Functions.action_explain(_action)
+      raise StandardError "action binding format must be `exchange:action/resource`" unless resource && action
 
       @opts[:header_bindings] << {
-          exchange: exchange,
-          arguments: {
-              action: action,
-              resource: resource
-          }
+        exchange: exchange,
+        arguments: {
+          action: action,
+          resource: resource
+        }.merge(custom_headers)
       }
     end
   end
 
-  def events_subscribes(events)
+  def events_subscribes(events, **custom_headers)
     events.each do |_event|
-      exchange, resource_event = _event.split(":")
-      if resource_event.nil?
-        resource_event = exchange
-        exchange = "strum.events"
-      end
-      raise StandardError "binding format must be `exchange:resource/event{/state}`" unless exchange && resource_event
-
-      resource, event, state = resource_event.split("/")
+      exchange, resource, event, state = Strum::Esb::Functions.event_explain(_event)
       raise StandardError "binding format must be `exchange:resource/event{/state}`" unless resource && event
 
       @opts[:header_bindings] << {
-          exchange: exchange,
-          arguments: {
-              resource: resource,
-              event: event,
-              state: state || "success"
-          }
+        exchange: exchange,
+        arguments: {
+          resource: resource,
+          event: event,
+          state: state
+        }.merge(custom_headers)
       }
     end
   end
 
-  def infos_subscribes(infos)
+  def infos_subscribes(infos, **custom_headers)
     infos.each do |_info|
-      exchange, resource = _info.split(":")
-      if resource.nil?
-        resource = exchange
-        exchange = "strum.info"
-      end
-      raise StandardError "binding format must be a `exchange:resource`" unless exchange && resource
+      exchange, resource = Strum::Esb::Functions.info_explain(_info)
+      raise StandardError "info binding format must be a `exchange:resource`" unless resource
 
       @opts[:header_bindings] << {
-          exchange: exchange,
-          arguments: {
-              info: resource
-          }
+        exchange: exchange,
+        arguments: {
+          info: resource
+        }.merge(custom_headers)
       }
     end
   end
 
-  def notices_subscribes(notices)
-    notices.each do |_info|
-      exchange, resource = _info.split(":")
-      if resource.nil?
-        resource = exchange
-        exchange = "strum.info"
-      end
-      raise StandardError "binding format must be a `exchange:resource`" unless exchange && resource
+  def notices_subscribes(notices, **custom_headers)
+    notices.each do |_notice|
+      exchange, resource, notice = Strum::Esb::Functions.notice_explain(_notice)
+      raise StandardError "notice binding format must be a `exchange:resource`" unless resource
 
       @opts[:header_bindings] << {
-          exchange: exchange,
-          arguments: {
-              notice: resource
-          }
+        exchange: exchange,
+        arguments: {
+          notice: notice,
+          resource: resource
+        }.merge(custom_headers)
       }
     end
   end
@@ -128,7 +125,11 @@ module QueuePatch
     header_bindings.each do |header_binding|
       exchange_name = header_binding[:exchange] || @opts[:exchange]
       exchange = @channel.exchange(exchange_name, @opts[:exchange_options].merge(type: :headers))
-      queue.bind(exchange, arguments: { "x-match": :all }.merge(header_binding[:arguments]))
+      queue.bind(exchange,
+                 arguments: {}.tap do |args|
+                              args["x-match"] = :all
+                            end
+                   .merge(header_binding[:arguments]))
     end
 
     handler = handler_klass.new(@channel, queue, worker.opts)
@@ -140,6 +141,8 @@ module QueuePatch
   end
 end
 
-class Sneakers::Queue
-  prepend QueuePatch
+module Sneakers
+  class Queue
+    prepend QueuePatch
+  end
 end

data/strum-esb.gemspec

@@ -1,4 +1,6 @@
-require_relative 'lib/strum/esb/version'
+# frozen_string_literal: true
+
+require_relative "lib/strum/esb/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "strum-esb"
@@ -8,18 +10,18 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Publish and subscribe rabbitMQ messages"
   spec.description   = "Publish and subscribe rabbitMQ messages"
-  spec.homepage      = "https://code.qpard.com/strum/strum-esb"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.homepage      = "https://gitlab.com/strum-rb/strum-esb"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://code.qpard.com/strum/strum-esb"
-  spec.metadata["changelog_uri"] = "https://code.qpard.com/strum/strum-esb/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "https://gitlab.com/strum-rb/strum-esb"
+  spec.metadata["changelog_uri"] = "https://gitlab.com/strum-rb/strum-esb/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
@@ -28,6 +30,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "bunny", "~> 2.15"
   spec.add_dependency "connection_pool", "~> 2.2.2"
+  spec.add_dependency "dry-configurable", "~> 0.12.1"
   spec.add_dependency "json", "~> 2.3"
   spec.add_dependency "sneakers", "~> 2.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strum-esb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Serhiy Nazarov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2021-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.2
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -74,10 +88,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitlab-ci.yml"
 - ".rspec"
 - ".rubocop.yml"
-- ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -87,6 +102,7 @@ files:
 - lib/strum/esb.rb
 - lib/strum/esb/action.rb
 - lib/strum/esb/event.rb
+- lib/strum/esb/functions.rb
 - lib/strum/esb/handler.rb
 - lib/strum/esb/info.rb
 - lib/strum/esb/message.rb
@@ -94,13 +110,13 @@ files:
 - lib/strum/esb/version.rb
 - lib/strum/patch/sneakers/queue_patch.rb
 - strum-esb.gemspec
-homepage: https://code.qpard.com/strum/strum-esb
+homepage: https://gitlab.com/strum-rb/strum-esb
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://code.qpard.com/strum/strum-esb
-  source_code_uri: https://code.qpard.com/strum/strum-esb
-  changelog_uri: https://code.qpard.com/strum/strum-esb/CHANGELOG.md
+  homepage_uri: https://gitlab.com/strum-rb/strum-esb
+  source_code_uri: https://gitlab.com/strum-rb/strum-esb
+  changelog_uri: https://gitlab.com/strum-rb/strum-esb/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -109,14 +125,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Publish and subscribe rabbitMQ messages

data/.ruby-version

@@ -1 +0,0 @@
-2.7.0