fleck 2.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecd7fdd80e3e92c7cfe1975c450d5f0cb7663dd91925bb2180b084a839aac0f8
-  data.tar.gz: 7f06df1290c2dd621493b705573b6072d7dbaff0385e53f5e72a1d9564411483
+  metadata.gz: 469551dc2d0172cea61bba8b982d70a6f8b68258f956c359602f02487490a77c
+  data.tar.gz: e2c0999b1da9cbf39246dd70dbeb3fcdec98072779a5bcc124ec4313c8a8e762
 SHA512:
-  metadata.gz: efc1b9f98d31737f4d92e845f30c072e43be49c40eac3f7350cc9aa4da25d2927da77cecf019dd3f6bc3580b3cde9ccef9494ce62b6dc8c37b557646b6331e22
-  data.tar.gz: 3cabbcac002ec6a030ac6c0eb1ebd75045b1a04b0d0e6f20697800da04c4f6d1f1389c27fcb064b18918e6ed839f790f4cbcd2d15c2bd37282745e54ef6df935
+  metadata.gz: b547f65455632875f7490343f19dfb6e0cc26e54f26358991786c983a9ed812f777046232c6bbd45dd7bda1e016899d0fd0cb9f58aa05273589f5a286c92a158
+  data.tar.gz: '03388d8f65b3ad560bcf62f6c9dddbd5a952d6f9a38a477457cab601259313c3ebd55b3ae7735c8f5dff5a4499215c5f7e0fac3c9c733f79ac8bae889b06eb20'

data/CHANGELOG.md

@@ -2,17 +2,47 @@
 
 ## develop ##
 
+### TAGS ###
+
+Below you can see the CHANGELOG of **Fleck** gem by version number.
+
+#### v2.2.0 (22 Dicember 2022) #####
+
+- **NEW** Implemented the feature which allows to add a modifier `lambda` to `param` decorator,
+          so that the value of parameter can be modified before proceeding with action execution.
+          Example: `param :name, ->(v) { v.to_s.strip.downcase }` will automatically convert the value of `name` parameter to string, will remove heading and trailing spaces and will transform to lower case.
+- **FIX** Correctly perform param `:max` validation.
+- **FIX** Move `HashWithIndifferentAccess` class under `Fleck` module, in order to avoid conflict with `ActiveSupport::HashWithIndifferentAccess`.
+
+#### v2.1.3 (10 February 2022) #####
+
+- **FIX** Correct nesting for `Fleck::HostRating` methods, in order to have correct context and visibility.
+
+#### v2.1.2 (10 February 2022) ####
+
+- **FIX** Autoload Fleck::HostRating from `fleck.rb`, instead of autoloading it from `configuration.rb`.
+
+#### v2.1.1 (9 February 2022) ####
+
+- **FIX** Correctly handle cases when `#ok!` helper method is used and a hash body is passed as argument.
+
+#### v2.1.0 (9 February 2022) ####
+
+- **NEW** Added automatic params and headers logging when logger level is set to DEBUG.
+
+#### v2.0.0 (31 Jannuary 2022) ####
+
 - **BREAKING CHANGE** Updated minimum required Ruby version to >= 2.5.
-- **NEW** Refactore `Fleck::Consumer` in order to have a better code structure.
+- **NEW** Refactored `Fleck::Consumer` in order to have a better code structure.
 - **NEW** Implemented response helpers, which allow to terminate the request with desired status code and message.
 - **NEW** Implemented action decorators, which allow to define an action and it's parameters directly before the method.
 - **NEW** Implemented action params automatic validation, which can be set by using action decorators.
 
-## v1.0.1 (2 April 2020) ##
+#### v1.0.1 (2 April 2020) ####
 
 - **BREAKING CHANGE** Updateg gemset, in order to be able to use new versions of Ruby.
 
-## v0.7.0 (21 June 2016) ##
+#### v0.7.0 (21 June 2016) ####
 
 - **NEW** Added multihost support to Fleck configuration, that allows to manage network failure situations and to choose the best options from the list of available hosts.
           This feature uses `Fleck::HostRating` to collect TCP latency data about each provided host, so that when a new connection is required, the host with lowest latency
@@ -22,7 +52,7 @@
 - **NEW** Implemented `:deprecated?` method for `Fleck::Consumer::Response`.
 - **NEW** Store client IP address to requests headers, in order to be able to trace requests origin when multiple clients making requests to the same consumer type.
 
-## v0.6.0 (16 June 2016)##
+#### v0.6.0 (16 June 2016) ####
 
 - **NEW** __(BREAKING CHANGE)__ Use `"fleck"` exchange for RPC simulation, so that reply queues could be used in a RabbitMQ Federation configuration.
           Be careful when upgrading `Fleck::Consumer` from version `v0.5.x` or below, because now `Fleck::Consumer` will send responses to a `:direct` exchange
@@ -32,12 +62,12 @@
 - **NEW** Implemented the feature that allows to start consumer in a blocking way.
 - **NEW** Added `:prefetch` and `:mandatory` options to `Fleck::Consumer` configuration options.
 
-## v0.5.1 (20 April 2016) ##
+#### v0.5.1 (20 April 2016) ####
 
 - **FIX** Don't expire requests with multiple responses if any response is received. Treat that kind of request as expired if no response has been received
           until the request expiration.
 
-## v0.5.0 (20 April 2016) ##
+#### v0.5.0 (20 April 2016) ####
 
 - **NEW** Added `:autostart` option to `Fleck::Consumer` configuration, so that the developer could decide to start the consumer manually or automatically. By default
           the consumer will start automatically.
@@ -56,11 +86,11 @@
 - **NEW** Add `app_name` configuration, that allows to configure the default `app_id` to set for RabbitMQ messages.
 - **NEW** Add process ID to logs, so that if you have multiple instances of the same application writting to the same log file, you'll be able to filter logs by process ID. Also changed logs format.
 
-## v0.4.1 (18 April 2016) ##
+#### v0.4.1 (18 April 2016) ####
 
 - **FIX** Fixed a bug of `Fleck::Consumer::Request` class, that was causing errors when RabbitMQ message header wasn't set.
 
-## v0.4.0 (15 April 2016) ##
+#### v0.4.0 (15 April 2016) ####
 
 - **NEW** Support different types of exchanges in both `Fleck::Client` and `Fleck::Consumer`.
 - **FIX** Use `auto_delete` queue for `Fleck::Client`, so that it is deleted when the client is terminated.
@@ -70,7 +100,7 @@
           `:params` option will be converted to JSON.
 - **NEW** Add `:action` option to `Fleck::Client::Request`, which will replace the action passed within `:headers` hash.
 
-## v0.3.0 (1 April 2016) ##
+#### v0.3.0 (1 April 2016) ####
 
 - **FIX** Use `:compat` mode when using `Oj` gem to dump/load JSON content.
 - **FIX** Prevent unnecessary `Fleck::Request` lock for response reception if the response already received.
@@ -83,7 +113,7 @@
           failed requests aren't requeued. You should call `response.reject(requeue: true)` within the `on_message` method, if you want to requeue the processing
           message.
 
-## v0.2.0 (18 February 2016) ##
+#### v0.2.0 (18 February 2016) ####
 
 - **NEW** `timeout` (synchronous requests only) and `queue` support for `Fleck::Client#request`
 - **NEW** Keywords arguments for `Fleck::Client#request` method (ex. `client.request(headers: {h1: v1, ...}, params: {p1: v2, ...}`)

data/fleck.gemspec

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-lib = File.expand_path(__dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'lib/fleck/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'fleck'
-  spec.platform      = 'ruby'
-  spec.version       = Fleck::VERSION
-  spec.authors       = ['Groza Sergiu']
-  spec.email         = ['serioja90@gmail.com']
-
-  spec.summary       = %(A Ruby gem for syncronous and asyncronous communication via Message Queue services.)
-  spec.description   = %(
-    Fleck is a library for syncronous and asyncronous communication over Message Queues services. Unlike a common
-    HTTP communication, Fleck requests and responses are pure JSON messages.
-  )
-  spec.homepage      = 'https://github.com/serioja90/fleck'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 2.5'
-
-  spec.add_development_dependency 'bundler', '>= 2.2.33'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.9'
-  spec.add_dependency             'bunny', '~> 2.14'
-  spec.add_dependency             'oj', '~> 3.10'
-  spec.add_dependency             'rainbow', '~> 2.2'
-  spec.add_dependency             'thread_safe', '~> 0.3'
-  spec.add_dependency             'ztimer', '~> 0.6'
-end
+# frozen_string_literal: true
+
+lib = File.expand_path(__dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lib/fleck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fleck'
+  spec.platform      = 'ruby'
+  spec.version       = Fleck::VERSION
+  spec.authors       = ['Groza Sergiu']
+  spec.email         = ['serioja90@gmail.com']
+
+  spec.summary       = %(A Ruby gem for syncronous and asyncronous communication via Message Queue services.)
+  spec.description   = %(
+    Fleck is a library for syncronous and asyncronous communication over Message Queues services. Unlike a common
+    HTTP communication, Fleck requests and responses are pure JSON messages.
+  )
+  spec.homepage      = 'https://github.com/serioja90/fleck'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.5'
+
+  spec.add_development_dependency 'bundler', '>= 2.2.33'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9'
+  spec.add_dependency             'bunny', '~> 2.14'
+  spec.add_dependency             'oj', '~> 3.10'
+  spec.add_dependency             'rainbow', '~> 2.2'
+  spec.add_dependency             'thread_safe', '~> 0.3'
+  spec.add_dependency             'ztimer', '~> 0.6'
+end

data/lib/fleck/consumer.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
-
-module Fleck
-  # A shorthand class for custom consumers definitions.
-  class Consumer < Fleck::Core::Consumer
-  end
-end
+# frozen_string_literal: true
+
+module Fleck
+  # A shorthand class for custom consumers definitions.
+  class Consumer < Fleck::Core::Consumer
+  end
+end

data/lib/fleck/core/consumer/action_param.rb

@@ -13,12 +13,13 @@ module Fleck
           'hash' => 'object'
         }.freeze
 
-        attr_reader :name, :type, :options
+        attr_reader :name, :type, :modifier, :options
 
-        def initialize(name, type, options = {})
+        def initialize(name, modifier = nil, **options)
           @name = name
-          @type = type
           @options = options
+          @modifier = modifier
+          @type = @options&.fetch(:type)
 
           check_options!
         end
@@ -32,13 +33,14 @@ module Fleck
         end
 
         def validate(value)
-          Validation.new(name, type, value, options)
+          Validation.new(name, type, value, modifier, **options)
         end
 
         private
 
         def check_options!
           check_type!
+          check_modifier!
           check_required!
           check_default!
           check_min_max!
@@ -55,6 +57,12 @@ module Fleck
           raise "Invalid param type: #{@type.inspect}" unless valid_type
         end
 
+        def check_modifier!
+          return if @modifier.nil? || @modifier.is_a?(Proc)
+
+          raise "Invalid modifier, lambda or Proc expected, got #{@modifier.class}"
+        end
+
         def check_required!
           options[:required] = (options[:required] == true)
         end

data/lib/fleck/core/consumer/base.rb

@@ -1,111 +1,111 @@
-# frozen_string_literal: true
-
-module Fleck
-  module Core
-    class Consumer
-      # Base methods for consumer setup, start and termination.
-      module Base
-        def self.included(base)
-          base.extend ClassMethods
-          base.send :include, InstanceMethods
-        end
-
-        # Defines class methods to import when `Autostart` module is imported.
-        module ClassMethods
-          attr_accessor :consumers, :initialize_block, :lock, :condition
-
-          def inherited(subclass)
-            super
-            return if subclass == Fleck::Consumer
-
-            init_consumer(subclass)
-            autostart(subclass)
-            Fleck.register_consumer(subclass)
-          end
-
-          def initialize(&block)
-            self.initialize_block = block
-          end
-
-          def start(block: false)
-            consumers.each(&:start)
-            wait_termination if block
-          end
-
-          def wait_termination
-            lock.synchronize { condition.wait(lock) }
-          end
-
-          def on_terminate(consumer)
-            consumers.delete consumer
-            terminate if consumers.empty?
-          end
-
-          def terminate
-            consumers.each(&:terminate)
-            lock.synchronize { condition.signal }
-          end
-
-          protected
-
-          def init_consumer(subclass)
-            configure_logger(subclass)
-
-            subclass.lock = Mutex.new
-            subclass.condition = ConditionVariable.new
-
-            subclass.configs = Fleck.config.default_options
-            subclass.actions_map = {}
-            subclass.consumers   = []
-          end
-
-          def configure_logger(subclass)
-            subclass.logger          = Fleck.logger.clone
-            subclass.logger.progname = subclass.to_s
-            subclass.logger.debug "Setting defaults for #{subclass.to_s.color(:yellow)} consumer"
-          end
-
-          def autostart(subclass)
-            # Use TracePoint to autostart the consumer when ready
-            trace = TracePoint.new(:end) do |tp|
-              if tp.self == subclass
-                # disable tracing when we reach the end of the subclass
-                trace.disable
-                # create a new instance of the subclass, in order to start the consumer
-                [subclass.configs[:concurrency].to_i, 1].max.times do |i|
-                  subclass.consumers << subclass.new(i)
-                end
-              end
-            end
-            trace.enable
-          end
-        end
-
-        # Defines instance methods to import when `Autostart` module is imported.
-        module InstanceMethods
-          def autostart?
-            configs[:autostart].nil? || configs[:autostart]
-          end
-
-          def start
-            logger.info "Launching #{self.class.to_s.color(:yellow)} consumer ..."
-            connect!
-            create_channel!
-            subscribe!
-          end
-
-          def terminate
-            pause
-
-            return if channel.nil? || channel.closed?
-
-            channel.close
-
-            logger.info 'Consumer successfully terminated.'
-            self.class.on_terminate(self)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      # Base methods for consumer setup, start and termination.
+      module Base
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `Autostart` module is imported.
+        module ClassMethods
+          attr_accessor :consumers, :initialize_block, :lock, :condition
+
+          def inherited(subclass)
+            super
+            return if subclass == Fleck::Consumer
+
+            init_consumer(subclass)
+            autostart(subclass)
+            Fleck.register_consumer(subclass)
+          end
+
+          def initialize(&block)
+            self.initialize_block = block
+          end
+
+          def start(block: false)
+            consumers.each(&:start)
+            wait_termination if block
+          end
+
+          def wait_termination
+            lock.synchronize { condition.wait(lock) }
+          end
+
+          def on_terminate(consumer)
+            consumers.delete consumer
+            terminate if consumers.empty?
+          end
+
+          def terminate
+            consumers.each(&:terminate)
+            lock.synchronize { condition.signal }
+          end
+
+          protected
+
+          def init_consumer(subclass)
+            configure_logger(subclass)
+
+            subclass.lock = Mutex.new
+            subclass.condition = ConditionVariable.new
+
+            subclass.configs = Fleck.config.default_options
+            subclass.actions_map = {}
+            subclass.consumers   = []
+          end
+
+          def configure_logger(subclass)
+            subclass.logger          = Fleck.logger.clone
+            subclass.logger.progname = subclass.to_s
+            subclass.logger.debug "Setting defaults for #{subclass.to_s.color(:yellow)} consumer"
+          end
+
+          def autostart(subclass)
+            # Use TracePoint to autostart the consumer when ready
+            trace = TracePoint.new(:end) do |tp|
+              if tp.self == subclass
+                # disable tracing when we reach the end of the subclass
+                trace.disable
+                # create a new instance of the subclass, in order to start the consumer
+                [subclass.configs[:concurrency].to_i, 1].max.times do |i|
+                  subclass.consumers << subclass.new(i)
+                end
+              end
+            end
+            trace.enable
+          end
+        end
+
+        # Defines instance methods to import when `Autostart` module is imported.
+        module InstanceMethods
+          def autostart?
+            configs[:autostart].nil? || configs[:autostart]
+          end
+
+          def start
+            logger.info "Launching #{self.class.to_s.color(:yellow)} consumer ..."
+            connect!
+            create_channel!
+            subscribe!
+          end
+
+          def terminate
+            pause
+
+            return if channel.nil? || channel.closed?
+
+            channel.close
+
+            logger.info 'Consumer successfully terminated.'
+            self.class.on_terminate(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fleck/core/consumer/decorators.rb

@@ -49,11 +49,11 @@ module Fleck
             method_options[:description] = description if description
           end
 
-          def param(name, options = {})
-            method_options[:params][name] = ActionParam.new(name, options[:type], options)
+          def param(name, modifier = nil, **options)
+            method_options[:params][name] = ActionParam.new(name, modifier, **options)
           end
 
-          def header(name, options = {})
+          def header(name, modifier = nil, **options)
             raise 'Not Implemented'
             # method_options[:headers][name] = ActionParam.new(name, options[:type], options)
           end

data/lib/fleck/core/consumer/validation.rb

@@ -6,9 +6,10 @@ module Fleck
       class Validation
         attr_reader :value, :errors
 
-        def initialize(name, type, value, options = {})
+        def initialize(name, type, value, modifier = nil, **options)
           @name = name
           @type         = type
+          @modifier     = modifier
           @value        = value || options[:default]
           @required     = (options[:required] == true)     # default: trues
           @allow_blank  = (options[:allow_blank] != false) # default: false
@@ -43,6 +44,8 @@ module Fleck
           when 'hash'    then validate_hash!
           when 'array'   then validate_array!
           end
+
+          apply_modifier!
         end
 
         def validate_string!
@@ -141,13 +144,19 @@ module Fleck
 
         def check_min_max!
           add_error(:min, "#{@name} should be greater than #{@min}") if @min && value < @min
-          add_error(:max, "#{@name} should be smaller than #{@max}") if @max && value < @max
+          add_error(:max, "#{@name} should be smaller than #{@max}") if @max && value > @max
         end
 
         def check_clamp!
           @value = @value.clamp(@clamp.first || -Float::INFINITY, @clamp.last || Float::INFINITY)
         end
 
+        def apply_modifier!
+          return if @modifier.nil?
+
+          @value = @modifier.call(@value)
+        end
+
         def numeric?
           !Float(value).nil?
         rescue ArgumentError

data/lib/fleck/core/consumer.rb

@@ -1,166 +1,166 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path(__dir__)
-
-module Fleck
-  module Core
-    # `Fleck::Core::Consumer` implements the core functionality for `Fleck::Consumer`,
-    # so that new `Fleck::Consumers` can be easily created by using inheritance.
-    class Consumer
-      autoload :Base, 'consumer/base.rb'
-      autoload :Actions, 'consumer/actions.rb'
-      autoload :Configuration, 'consumer/configuration.rb'
-      autoload :Decorators, 'consumer/decorators.rb'
-      autoload :HelpersDefiners, 'consumer/helpers_definers.rb'
-      autoload :Logger, 'consumer/logger.rb'
-
-      autoload :Request, 'consumer/request.rb'
-      autoload :Response, 'consumer/response.rb'
-
-      autoload :ActionHeader, 'consumer/action_header.rb'
-      autoload :ActionParam, 'consumer/action_param.rb'
-      autoload :Validation, 'consumer/validation.rb'
-
-      include Fleck::Loggable
-      include Logger
-      include Actions
-      include Configuration
-      include Decorators
-      include HelpersDefiners
-      include Base
-
-      require_relative 'consumer/response_helpers'
-
-      attr_accessor :connection, :channel, :queue, :publisher, :consumer_tag, :request, :subscription, :exchange,
-                    :consumer_id
-
-      def initialize(consumer_id = nil)
-        self.consumer_id = consumer_id
-
-        instance_eval(&self.class.initialize_block) if self.class.initialize_block
-
-        start if autostart?
-
-        at_exit do
-          terminate
-        end
-      end
-
-      def pause
-        return if subscription.nil? || channel.nil? || channel.closed?
-
-        cancel_ok = subscription.cancel
-        self.consumer_tag = cancel_ok.consumer_tag
-      end
-
-      def resume
-        subscribe!
-      end
-
-      def headers
-        request.headers
-      end
-
-      def params
-        request.params
-      end
-
-      def response
-        request.response
-      end
-
-      def deprecated!
-        logger.warn "DEPRECATION: the method `#{caller_locations(1, 1)[0].label}` is going to be deprecated. " \
-                    'Please, consider using a newer version of this method.'
-        response&.deprecated!
-      end
-
-      protected
-
-      def connect!
-        self.connection = Fleck.connection(
-          host: rmq_host,
-          port: rmq_port,
-          user: rmq_user,
-          pass: rmq_pass,
-          vhost: rmq_vhost
-        )
-      end
-
-      def create_channel!
-        if channel && !channel.closed?
-          logger.info('Closing the opened channel...')
-          channel.close
-        end
-
-        logger.debug "Creating a new channel for #{self.class.to_s.color(:yellow)} consumer"
-        self.channel = connection.create_channel
-        channel.prefetch(prefetch_size) # consume messages in batches
-        self.publisher = Bunny::Exchange.new(connection.create_channel, :direct, 'fleck')
-        if rmq_exchange_type == :direct && rmq_exchange_name == ''
-          self.queue = channel.queue(queue_name, auto_delete: false)
-        else
-          self.exchange = Bunny::Exchange.new(channel, rmq_exchange_type, rmq_exchange_name)
-          self.queue = channel.queue('', exclusive: true, auto_delete: true).bind(exchange, routing_key: queue_name)
-        end
-      end
-
-      def subscribe!
-        logger.debug "Consuming from queue: #{queue_name.color(:green)}"
-
-        options = { manual_ack: true }
-        options[:consumer_tag] = consumer_tag if consumer_tag
-
-        self.subscription = queue.subscribe(options) do |delivery_info, metadata, payload|
-          process_request!(metadata, payload, delivery_info)
-        end
-      end
-
-      def process_request!(metadata, payload, delivery_info)
-        self.request = Request.new(metadata, payload, delivery_info)
-
-        catch(INTERRUPT_NAME) do
-          execute_action! unless request.failed?
-        end
-      rescue StandardError => e
-        log_error(e)
-        internal_server_error! e.inspect, interrupt: false
-      ensure
-        send_response!
-        log_request
-      end
-
-      def send_response!
-        return reject_request! if request.rejected?
-
-        logger.debug "Sending response: #{response}"
-
-        if channel.closed?
-          return logger.warn "Channel already closed! The response #{request.id} is going to be dropped."
-        end
-
-        publish_response!
-        request.processed!
-      end
-
-      def reject_request!
-        channel.reject(request.delivery_tag, request.requeue?)
-      end
-
-      def publish_response!
-        publisher.publish(
-          response.to_json,
-          routing_key: request.reply_to,
-          correlation_id: request.id,
-          mandatory: ack_mandatory?
-        )
-        channel.ack(request.delivery_tag)
-      end
-
-      def restart!
-        create_channel!
-        subscribe!
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(__dir__)
+
+module Fleck
+  module Core
+    # `Fleck::Core::Consumer` implements the core functionality for `Fleck::Consumer`,
+    # so that new `Fleck::Consumers` can be easily created by using inheritance.
+    class Consumer
+      autoload :Base, 'consumer/base.rb'
+      autoload :Actions, 'consumer/actions.rb'
+      autoload :Configuration, 'consumer/configuration.rb'
+      autoload :Decorators, 'consumer/decorators.rb'
+      autoload :HelpersDefiners, 'consumer/helpers_definers.rb'
+      autoload :Logger, 'consumer/logger.rb'
+
+      autoload :Request, 'consumer/request.rb'
+      autoload :Response, 'consumer/response.rb'
+
+      autoload :ActionHeader, 'consumer/action_header.rb'
+      autoload :ActionParam, 'consumer/action_param.rb'
+      autoload :Validation, 'consumer/validation.rb'
+
+      include Fleck::Loggable
+      include Logger
+      include Actions
+      include Configuration
+      include Decorators
+      include HelpersDefiners
+      include Base
+
+      require_relative 'consumer/response_helpers'
+
+      attr_accessor :connection, :channel, :queue, :publisher, :consumer_tag, :request, :subscription, :exchange,
+                    :consumer_id
+
+      def initialize(consumer_id = nil)
+        self.consumer_id = consumer_id
+
+        instance_eval(&self.class.initialize_block) if self.class.initialize_block
+
+        start if autostart?
+
+        at_exit do
+          terminate
+        end
+      end
+
+      def pause
+        return if subscription.nil? || channel.nil? || channel.closed?
+
+        cancel_ok = subscription.cancel
+        self.consumer_tag = cancel_ok.consumer_tag
+      end
+
+      def resume
+        subscribe!
+      end
+
+      def headers
+        request.headers
+      end
+
+      def params
+        request.params
+      end
+
+      def response
+        request.response
+      end
+
+      def deprecated!
+        logger.warn "DEPRECATION: the method `#{caller_locations(1, 1)[0].label}` is going to be deprecated. " \
+                    'Please, consider using a newer version of this method.'
+        response&.deprecated!
+      end
+
+      protected
+
+      def connect!
+        self.connection = Fleck.connection(
+          host: rmq_host,
+          port: rmq_port,
+          user: rmq_user,
+          pass: rmq_pass,
+          vhost: rmq_vhost
+        )
+      end
+
+      def create_channel!
+        if channel && !channel.closed?
+          logger.info('Closing the opened channel...')
+          channel.close
+        end
+
+        logger.debug "Creating a new channel for #{self.class.to_s.color(:yellow)} consumer"
+        self.channel = connection.create_channel
+        channel.prefetch(prefetch_size) # consume messages in batches
+        self.publisher = Bunny::Exchange.new(connection.create_channel, :direct, 'fleck')
+        if rmq_exchange_type == :direct && rmq_exchange_name == ''
+          self.queue = channel.queue(queue_name, auto_delete: false)
+        else
+          self.exchange = Bunny::Exchange.new(channel, rmq_exchange_type, rmq_exchange_name)
+          self.queue = channel.queue('', exclusive: true, auto_delete: true).bind(exchange, routing_key: queue_name)
+        end
+      end
+
+      def subscribe!
+        logger.debug "Consuming from queue: #{queue_name.color(:green)}"
+
+        options = { manual_ack: true }
+        options[:consumer_tag] = consumer_tag if consumer_tag
+
+        self.subscription = queue.subscribe(options) do |delivery_info, metadata, payload|
+          process_request!(metadata, payload, delivery_info)
+        end
+      end
+
+      def process_request!(metadata, payload, delivery_info)
+        self.request = Request.new(metadata, payload, delivery_info)
+
+        catch(INTERRUPT_NAME) do
+          execute_action! unless request.failed?
+        end
+      rescue StandardError => e
+        log_error(e)
+        internal_server_error! e.inspect, interrupt: false
+      ensure
+        send_response!
+        log_request
+      end
+
+      def send_response!
+        return reject_request! if request.rejected?
+
+        logger.debug "Sending response: #{response}"
+
+        if channel.closed?
+          return logger.warn "Channel already closed! The response #{request.id} is going to be dropped."
+        end
+
+        publish_response!
+        request.processed!
+      end
+
+      def reject_request!
+        channel.reject(request.delivery_tag, request.requeue?)
+      end
+
+      def publish_response!
+        publisher.publish(
+          response.to_json,
+          routing_key: request.reply_to,
+          correlation_id: request.id,
+          mandatory: ack_mandatory?
+        )
+        channel.ack(request.delivery_tag)
+      end
+
+      def restart!
+        create_channel!
+        subscribe!
+      end
+    end
+  end
+end

data/lib/fleck/core.rb

@@ -1,9 +1,9 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path(__dir__)
-
-module Fleck
-  module Core
-    autoload :Consumer, 'core/consumer.rb'
-  end
-end
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(__dir__)
+
+module Fleck
+  module Core
+    autoload :Consumer, 'core/consumer.rb'
+  end
+end

data/lib/fleck/utilities/hash_with_indifferent_access.rb

@@ -1,80 +1,82 @@
-# frozen_string_literal: true
-
-# `HashWithIndifferentAccess` extends `Hash` class and adds the possibility to access values
-# by using both string and symbol keys indifferently.
-class HashWithIndifferentAccess < Hash
-  def initialize(original)
-    super(nil)
-    copy_from(original)
-  end
-
-  def []=(key, value)
-    super(key.to_s, self.class.convert_value(value))
-  end
-
-  def [](key)
-    super(key.to_s)
-  end
-
-  def fetch(key, *extras)
-    super(key.to_s, *extras)
-  end
-
-  def delete(key)
-    super(key.to_s)
-  end
-
-  def self.convert_value(value)
-    case value
-    when Hash
-      value.to_hash_with_indifferent_access
-    when Array
-      value.map! { |item| item.is_a?(Hash) || item.is_a?(Array) ? HashWithIndifferentAccess.convert_value(item) : item }
-    else
-      value
-    end
-  end
-
-  protected
-
-  def copy_from(original)
-    original.each do |key, value|
-      self[key] = self.class.convert_value(value)
-    end
-  end
-end
-
-# Open `Hash` class to add `#to_hash_with_indifferent_access` method and some filter features.
-class Hash
-  def to_hash_with_indifferent_access
-    HashWithIndifferentAccess.new(self)
-  end
-
-  def to_s
-    return dup.filter!.inspect if @filtered
-
-    super
-  end
-
-  def filtered!
-    @filtered = true
-    keys.each do |key|
-      self[key].filtered! if self[key].is_a?(Hash)
-    end
-
-    self
-  end
-
-  def filter!
-    filters = Fleck.config.filters
-    keys.each do |key|
-      if filters.include?(key.to_s)
-        self[key] = '[FILTERED]'
-      elsif self[key].is_a?(Hash)
-        self[key] = self[key].dup.filter!
-      end
-    end
-
-    self
-  end
-end
+# frozen_string_literal: true
+
+module Fleck
+  # `HashWithIndifferentAccess` extends `Hash` class and adds the possibility to access values
+  # by using both string and symbol keys indifferently.
+  class HashWithIndifferentAccess < Hash
+    def initialize(original)
+      super(nil)
+      copy_from(original)
+    end
+
+    def []=(key, value)
+      super(key.to_s, self.class.convert_value(value))
+    end
+
+    def [](key)
+      super(key.to_s)
+    end
+
+    def fetch(key, *extras)
+      super(key.to_s, *extras)
+    end
+
+    def delete(key)
+      super(key.to_s)
+    end
+
+    def self.convert_value(value)
+      case value
+      when Hash
+        value.to_hash_with_indifferent_access
+      when Array
+        value.map! { |item| item.is_a?(Hash) || item.is_a?(Array) ? Fleck::HashWithIndifferentAccess.convert_value(item) : item }
+      else
+        value
+      end
+    end
+
+    protected
+
+    def copy_from(original)
+      original.each do |key, value|
+        self[key] = self.class.convert_value(value)
+      end
+    end
+  end
+end
+
+# Open `Hash` class to add `#to_hash_with_indifferent_access` method and some filter features.
+class Hash
+  def to_hash_with_indifferent_access
+    Fleck::HashWithIndifferentAccess.new(self)
+  end
+
+  def to_s
+    return dup.filter!.inspect if @filtered
+
+    super
+  end
+
+  def filtered!
+    @filtered = true
+    keys.each do |key|
+      self[key].filtered! if self[key].is_a?(Hash)
+    end
+
+    self
+  end
+
+  def filter!
+    filters = Fleck.config.filters
+    keys.each do |key|
+      if filters.include?(key.to_s)
+        self[key] = '[FILTERED]'
+      elsif self[key].is_a?(Hash)
+        self[key] = self[key].dup.filter!
+      end
+    end
+
+    self
+  end
+end

data/lib/fleck/utilities/host_rating.rb

@@ -64,41 +64,39 @@ module Fleck
     ensure
       @updated_at = Time.now
     end
-  end
 
-  private
+    # Use a socket to test connection latency.
+    def measure_latency
+      socket = create_socket
 
-  # Use a socket to test connection latency.
-  def measure_latency
-    socket = create_socket
+      started_at = Time.now.to_f
+      begin
+        socket.connect_nonblock(sock_addr)
+      rescue IO::WaitWritable
+        IO.select(nil, [socket], nil, CONN_TIMEOUT) or raise Timeout::Error
+      end
 
-    started_at = Time.now.to_f
-    begin
-      socket.connect_nonblock(sock_addr)
-    rescue IO::WaitWritable
-      IO.select(nil, [socket], nil, CONN_TIMEOUT) or raise Timeout::Error
+      (Time.now.to_f - started_at) * 1000 # ms
+    ensure
+      socket&.close
     end
 
-    (Time.now.to_f - started_at) * 1000 # ms
-  ensure
-    socket&.close
-  end
-
-  # Create a new socket for connection test.
-  def create_socket
-    socket = Socket.new(:AF_INET, :SOCK_STREAM, 0)
-    socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+    # Create a new socket for connection test.
+    def create_socket
+      socket = Socket.new(:AF_INET, :SOCK_STREAM, 0)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
-    socket
-  end
+      socket
+    end
 
-  # Resolve domain name in order to obtain IP address to test.
-  def sock_addr
-    return @sock_addr if @sock_addr
+    # Resolve domain name in order to obtain IP address to test.
+    def sock_addr
+      return @sock_addr if @sock_addr
 
-    addr = Socket.getaddrinfo(@host, nil)
-    @sock_addr = Socket.pack_sockaddr_in(@port, addr[0][3])
+      addr = Socket.getaddrinfo(@host, nil)
+      @sock_addr = Socket.pack_sockaddr_in(@port, addr[0][3])
 
-    @sock_addr
+      @sock_addr
+    end
   end
 end

data/lib/fleck/version.rb

@@ -1,6 +1,6 @@
-# frozen_string_literal: true
-
-# Open `Fleck` module to set `VERSION` constant.
-module Fleck
-  VERSION = '2.1.2'
-end
+# frozen_string_literal: true
+
+# Open `Fleck` module to set `VERSION` constant.
+module Fleck
+  VERSION = '2.2.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fleck
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -193,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A Ruby gem for syncronous and asyncronous communication via Message Queue