fleck 2.2.0 → 2.2.2

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

@@ -1,81 +1,81 @@
-# frozen_string_literal: true
-
-module Fleck
-  module Core
-    # Open `Consumer` class in order to define consumer helpers
-    class Consumer
-      # Define methods for 1xx codes
-      information_method :continue!, 100
-      information_method :switching_protocols!, 101
-      information_method :processing!, 102
-      information_method :early_hints!, 103
-
-      # Define methods for 2xx codes
-      success_method :ok!, 200
-      success_method :created!, 201
-      success_method :accepted!, 202
-      success_method :non_authoritative_information!, 203
-      success_method :no_content!, 204
-      success_method :reset_content!, 205
-      success_method :partial_content!, 206
-      success_method :multi_status!, 207
-      success_method :already_reported!, 208
-      success_method :im_used!, 226
-
-      # Define methods for 3xx codes
-      redirect_method :multiple_choice!, 300
-      redirect_method :moved_permanently!, 301
-      redirect_method :found!, 302
-      redirect_method :see_other!, 303
-      redirect_method :not_modified!, 304
-      redirect_method :use_proxy!, 305
-      redirect_method :unused!, 306
-      redirect_method :temporary_redirect!, 307
-      redirect_method :permanent_redirect!, 308
-
-      # Define methods for 4xx errors
-      error_method :bad_request!, 400, 'Bad Request'
-      error_method :unauthorized!, 401, 'Unauthorized'
-      error_method :payment_required!, 402, 'Payment Required'
-      error_method :forbidden!, 403, 'Forbidden'
-      error_method :not_found!, 404, 'Not Found'
-      error_method :method_not_allowed!, 405, 'Method Not Allowed'
-      error_method :not_acceptable!, 406, 'Not Acceptable'
-      error_method :proxy_authentication_required!, 407, 'Proxy Authentication Required'
-      error_method :request_timeout!, 408, 'Request Timeout'
-      error_method :conflict!, 409, 'Conflict'
-      error_method :gone!, 410, 'Gone'
-      error_method :length_required!, 411, 'Length Required'
-      error_method :precondition_failed!, 412, 'Precondition Failed'
-      error_method :payload_too_large!, 413, 'Payload Too Large'
-      error_method :uri_too_long!, 414, 'URI Too Long'
-      error_method :unsupported_media_type!, 415, 'Unsupported Media Type'
-      error_method :range_not_satisfiable!, 416, 'Range Not Satisfiable'
-      error_method :expectation_failed!, 417, 'Expectation Failed'
-      error_method :im_a_teapot!, 418, "I'm a teapot"
-      error_method :misdirected_request!, 421, 'Misdirected Request'
-      error_method :unprocessable_entity!, 422, 'Unprocessable Entity'
-      error_method :locked!, 423, 'Locked'
-      error_method :failed_dependency!, 424, 'Failed Dependency'
-      error_method :too_early!, 425, 'Too Early'
-      error_method :upgrade_required!, 426, 'Upgrade Required'
-      error_method :precondition_required!, 428, 'Precondition Required'
-      error_method :too_many_requests!, 429, 'Too Many Requests'
-      error_method :request_header_fields_too_large!, 431, 'Request Header Fields Too Large'
-      error_method :unavailable_for_legal_reasons!, 451, 'Unavailable For Legal Reasons'
-
-      # Define methods for 5xx errors
-      error_method :internal_server_error!, 500, 'Internal Server Error'
-      error_method :not_implemented!, 501, 'Not Implemented'
-      error_method :bad_gateway!, 502, 'Bad Gateway'
-      error_method :service_unavailable!, 503, 'Service Unavailable'
-      error_method :gateway_timeout!, 504, 'Gateway Timeout'
-      error_method :http_version_not_supported!, 505, 'HTTP Version Not Supported'
-      error_method :variant_also_negotiates!, 506, 'Variant Also Negotiates'
-      error_method :insufficient_storage!, 507, 'Insufficient Storage'
-      error_method :loop_detected!, 508, 'Loop Detected'
-      error_method :not_extended!, 510, 'Not Extended'
-      error_method :network_authentication_required!, 511, 'Network Authentication Required'
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    # Open `Consumer` class in order to define consumer helpers
+    class Consumer
+      # Define methods for 1xx codes
+      information_method :continue!, 100
+      information_method :switching_protocols!, 101
+      information_method :processing!, 102
+      information_method :early_hints!, 103
+
+      # Define methods for 2xx codes
+      success_method :ok!, 200
+      success_method :created!, 201
+      success_method :accepted!, 202
+      success_method :non_authoritative_information!, 203
+      success_method :no_content!, 204
+      success_method :reset_content!, 205
+      success_method :partial_content!, 206
+      success_method :multi_status!, 207
+      success_method :already_reported!, 208
+      success_method :im_used!, 226
+
+      # Define methods for 3xx codes
+      redirect_method :multiple_choice!, 300
+      redirect_method :moved_permanently!, 301
+      redirect_method :found!, 302
+      redirect_method :see_other!, 303
+      redirect_method :not_modified!, 304
+      redirect_method :use_proxy!, 305
+      redirect_method :unused!, 306
+      redirect_method :temporary_redirect!, 307
+      redirect_method :permanent_redirect!, 308
+
+      # Define methods for 4xx errors
+      error_method :bad_request!, 400, 'Bad Request'
+      error_method :unauthorized!, 401, 'Unauthorized'
+      error_method :payment_required!, 402, 'Payment Required'
+      error_method :forbidden!, 403, 'Forbidden'
+      error_method :not_found!, 404, 'Not Found'
+      error_method :method_not_allowed!, 405, 'Method Not Allowed'
+      error_method :not_acceptable!, 406, 'Not Acceptable'
+      error_method :proxy_authentication_required!, 407, 'Proxy Authentication Required'
+      error_method :request_timeout!, 408, 'Request Timeout'
+      error_method :conflict!, 409, 'Conflict'
+      error_method :gone!, 410, 'Gone'
+      error_method :length_required!, 411, 'Length Required'
+      error_method :precondition_failed!, 412, 'Precondition Failed'
+      error_method :payload_too_large!, 413, 'Payload Too Large'
+      error_method :uri_too_long!, 414, 'URI Too Long'
+      error_method :unsupported_media_type!, 415, 'Unsupported Media Type'
+      error_method :range_not_satisfiable!, 416, 'Range Not Satisfiable'
+      error_method :expectation_failed!, 417, 'Expectation Failed'
+      error_method :im_a_teapot!, 418, "I'm a teapot"
+      error_method :misdirected_request!, 421, 'Misdirected Request'
+      error_method :unprocessable_entity!, 422, 'Unprocessable Entity'
+      error_method :locked!, 423, 'Locked'
+      error_method :failed_dependency!, 424, 'Failed Dependency'
+      error_method :too_early!, 425, 'Too Early'
+      error_method :upgrade_required!, 426, 'Upgrade Required'
+      error_method :precondition_required!, 428, 'Precondition Required'
+      error_method :too_many_requests!, 429, 'Too Many Requests'
+      error_method :request_header_fields_too_large!, 431, 'Request Header Fields Too Large'
+      error_method :unavailable_for_legal_reasons!, 451, 'Unavailable For Legal Reasons'
+
+      # Define methods for 5xx errors
+      error_method :internal_server_error!, 500, 'Internal Server Error'
+      error_method :not_implemented!, 501, 'Not Implemented'
+      error_method :bad_gateway!, 502, 'Bad Gateway'
+      error_method :service_unavailable!, 503, 'Service Unavailable'
+      error_method :gateway_timeout!, 504, 'Gateway Timeout'
+      error_method :http_version_not_supported!, 505, 'HTTP Version Not Supported'
+      error_method :variant_also_negotiates!, 506, 'Variant Also Negotiates'
+      error_method :insufficient_storage!, 507, 'Insufficient Storage'
+      error_method :loop_detected!, 508, 'Loop Detected'
+      error_method :not_extended!, 510, 'Not Extended'
+      error_method :network_authentication_required!, 511, 'Network Authentication Required'
+    end
+  end
+end

data/lib/fleck/core/consumer.rb

@@ -124,7 +124,7 @@ module Fleck
         end
       rescue StandardError => e
         log_error(e)
-        internal_server_error! e.inspect, interrupt: false
+        internal_server_error! error: e.inspect, interrupt: false
       ensure
         send_response!
         log_request

data/lib/fleck/loggable.rb

@@ -1,15 +1,15 @@
-
-module Fleck::Loggable
-  def logger
-    return @logger if @logger
-
-    @logger = Fleck.logger.clone
-    @logger.progname = self.class.name
-
-    @logger
-  end
-
-  def log_error(error)
-    logger.error "#{error.inspect}\n#{error.backtrace.join("\n")}"
-  end
-end
+
+module Fleck::Loggable
+  def logger
+    return @logger if @logger
+
+    @logger = Fleck.logger.clone
+    @logger.progname = self.class.name
+
+    @logger
+  end
+
+  def log_error(error)
+    logger.error "#{error.inspect}\n#{error.backtrace.join("\n")}"
+  end
+end

data/lib/fleck/utilities/host_rating.rb

@@ -1,102 +1,102 @@
-# frozen_string_literal: true
-
-require 'socket'
-
-# Open `Fleck` module to add `HostRating` class.
-module Fleck
-  # `HostRating` class allows to test host latency on a regular basis and to compare the latency
-  # with other hosts.
-  class HostRating
-    include Fleck::Loggable
-
-    CONN_TIMEOUT = 5
-
-    attr_reader :host, :port, :avg, :history
-
-    def initialize(host: 'localhost', port: 5672, refresh_rate: 30_000, period: 300_000)
-      @host         = host
-      @port         = port
-      @refresh_rate = refresh_rate
-      @period       = period
-
-      # metrics
-      @reachable  = false
-      @avg        = 0
-      @updated_at = nil
-      @history    = []
-
-      refresh!
-      @timer = Ztimer.every(@refresh_rate) { refresh! }
-    end
-
-    def reachable?
-      @reachable
-    end
-
-    def close
-      @timer.cancel!
-    end
-
-    def <=>(other)
-      # the other host is reachable, so it comes first
-      return 1 if !reachable? && other.reachable?
-
-      # both host are unreachable, so they have the same priority
-      return 0 unless reachable? || other.reachable?
-
-      # the current host comes first, because it's reachable, while the other host is unreachable
-      return -1 if reachable? && !other.reachable?
-
-      # when both hosts are reachable, use avg latency to order them
-      avg <=> other.avg
-    end
-
-    private
-
-    def refresh!
-      @history << measure_latency
-      @history.shift if @history.size > @period / @refresh_rate
-      @avg = @history.inject(:+).to_f / @history.size
-      @reachable = true
-    rescue SocketError, Timeout::Error => e
-      @reachable = false
-      logger.error "Connection error: #{@host}:#{@port} (#{e.inspect})"
-    ensure
-      @updated_at = Time.now
-    end
-
-    # 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
-
-      (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)
-
-      socket
-    end
-
-    # 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])
-
-      @sock_addr
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'socket'
+
+# Open `Fleck` module to add `HostRating` class.
+module Fleck
+  # `HostRating` class allows to test host latency on a regular basis and to compare the latency
+  # with other hosts.
+  class HostRating
+    include Fleck::Loggable
+
+    CONN_TIMEOUT = 5
+
+    attr_reader :host, :port, :avg, :history
+
+    def initialize(host: 'localhost', port: 5672, refresh_rate: 30_000, period: 300_000)
+      @host         = host
+      @port         = port
+      @refresh_rate = refresh_rate
+      @period       = period
+
+      # metrics
+      @reachable  = false
+      @avg        = 0
+      @updated_at = nil
+      @history    = []
+
+      refresh!
+      @timer = Ztimer.every(@refresh_rate) { refresh! }
+    end
+
+    def reachable?
+      @reachable
+    end
+
+    def close
+      @timer.cancel!
+    end
+
+    def <=>(other)
+      # the other host is reachable, so it comes first
+      return 1 if !reachable? && other.reachable?
+
+      # both host are unreachable, so they have the same priority
+      return 0 unless reachable? || other.reachable?
+
+      # the current host comes first, because it's reachable, while the other host is unreachable
+      return -1 if reachable? && !other.reachable?
+
+      # when both hosts are reachable, use avg latency to order them
+      avg <=> other.avg
+    end
+
+    private
+
+    def refresh!
+      @history << measure_latency
+      @history.shift if @history.size > @period / @refresh_rate
+      @avg = @history.inject(:+).to_f / @history.size
+      @reachable = true
+    rescue SocketError, Timeout::Error => e
+      @reachable = false
+      logger.error "Connection error: #{@host}:#{@port} (#{e.inspect})"
+    ensure
+      @updated_at = Time.now
+    end
+
+    # 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
+
+      (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)
+
+      socket
+    end
+
+    # 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])
+
+      @sock_addr
+    end
+  end
+end

data/lib/fleck/version.rb

@@ -2,5 +2,5 @@
 
 # Open `Fleck` module to set `VERSION` constant.
 module Fleck
-  VERSION = '2.2.0'
+  VERSION = '2.2.2'
 end

data/lib/fleck.rb

@@ -1,82 +1,82 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path(__dir__)
-
-require 'English'
-require 'logger'
-require 'rainbow'
-require 'rainbow/ext/string'
-require 'bunny'
-require 'thread_safe'
-require 'securerandom'
-require 'oj'
-require 'ztimer'
-# require 'fleck/version'
-require 'fleck/utilities/hash_with_indifferent_access'
-# require 'fleck/loggable'
-# require 'fleck/host_rating'
-# require 'fleck/configuration'
-# require 'fleck/consumer'
-# require 'fleck/client'
-
-# `Fleck` module implements the features for `Fleck` configuration and messages production/consumption.
-module Fleck
-  autoload :VERSION, 'fleck/version.rb'
-  autoload :Loggable, 'fleck/loggable.rb'
-  autoload :HostRating, 'fleck/utilities/host_rating.rb'
-  autoload :Configuration, 'fleck/configuration.rb'
-  autoload :Core, 'fleck/core.rb'
-  autoload :Consumer, 'fleck/consumer.rb'
-  autoload :Client, 'fleck/client.rb'
-
-  @config      = Configuration.new
-  @consumers   = ThreadSafe::Array.new
-  @connections = ThreadSafe::Hash.new
-
-  class << self
-    attr_reader :config, :consumers
-
-    def configure
-      yield @config if block_given?
-      @config
-    end
-
-    def logger
-      @config.logger
-    end
-
-    def register_consumer(consumer_class)
-      return if @consumers.include?(consumer_class)
-
-      @consumers << consumer_class
-    end
-
-    def connection(options = {})
-      opts = Fleck.config.default_options.merge(options)
-      key  = "ampq://#{opts[:user]}@#{opts[:host]}:#{opts[:port]}#{opts[:vhost]}"
-      conn = @connections[key]
-      if !conn || conn.closed?
-        opts[:logger] = Fleck.logger.clone
-        opts[:logger].progname += '::Bunny'
-        logger.info "New connection #{key}"
-        conn = Bunny.new(opts)
-        conn.start
-        @connections[key] = conn
-      end
-
-      conn
-    end
-
-    def terminate
-      @connections.each do |key, connection|
-        Fleck.logger.info "Closing connection #{key}"
-        connection.close
-      rescue StandardError => e
-        Fleck.logger.error e.inspect
-      end
-      @connections.clear
-
-      true
-    end
-  end
-end
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(__dir__)
+
+require 'English'
+require 'logger'
+require 'rainbow'
+require 'rainbow/ext/string'
+require 'bunny'
+require 'thread_safe'
+require 'securerandom'
+require 'oj'
+require 'ztimer'
+# require 'fleck/version'
+require 'fleck/utilities/hash_with_indifferent_access'
+# require 'fleck/loggable'
+# require 'fleck/host_rating'
+# require 'fleck/configuration'
+# require 'fleck/consumer'
+# require 'fleck/client'
+
+# `Fleck` module implements the features for `Fleck` configuration and messages production/consumption.
+module Fleck
+  autoload :VERSION, 'fleck/version.rb'
+  autoload :Loggable, 'fleck/loggable.rb'
+  autoload :HostRating, 'fleck/utilities/host_rating.rb'
+  autoload :Configuration, 'fleck/configuration.rb'
+  autoload :Core, 'fleck/core.rb'
+  autoload :Consumer, 'fleck/consumer.rb'
+  autoload :Client, 'fleck/client.rb'
+
+  @config      = Configuration.new
+  @consumers   = ThreadSafe::Array.new
+  @connections = ThreadSafe::Hash.new
+
+  class << self
+    attr_reader :config, :consumers
+
+    def configure
+      yield @config if block_given?
+      @config
+    end
+
+    def logger
+      @config.logger
+    end
+
+    def register_consumer(consumer_class)
+      return if @consumers.include?(consumer_class)
+
+      @consumers << consumer_class
+    end
+
+    def connection(options = {})
+      opts = Fleck.config.default_options.merge(options)
+      key  = "ampq://#{opts[:user]}@#{opts[:host]}:#{opts[:port]}#{opts[:vhost]}"
+      conn = @connections[key]
+      if !conn || conn.closed?
+        opts[:logger] = Fleck.logger.clone
+        opts[:logger].progname += '::Bunny'
+        logger.info "New connection #{key}"
+        conn = Bunny.new(opts)
+        conn.start
+        @connections[key] = conn
+      end
+
+      conn
+    end
+
+    def terminate
+      @connections.each do |key, connection|
+        Fleck.logger.info "Closing connection #{key}"
+        connection.close
+      rescue StandardError => e
+        Fleck.logger.error e.inspect
+      end
+      @connections.clear
+
+      true
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fleck
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-22 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,14 +112,14 @@ dependencies:
   name: ztimer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.6'
 description: "\n    Fleck is a library for syncronous and asyncronous communication
@@ -193,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: A Ruby gem for syncronous and asyncronous communication via Message Queue