fleck 1.0.1 → 2.0.0

data/lib/fleck/core/consumer.rb

@@ -0,0 +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

data/lib/fleck/core.rb

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

data/lib/fleck/loggable.rb

@@ -1,10 +1,15 @@
-
-module Fleck::Loggable
-  def logger
-    return @logger if @logger
-    @logger = Fleck.logger.clone
-    @logger.progname = self.class.name
-
-    @logger
-  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/{hash_with_indifferent_access.rb → utilities/hash_with_indifferent_access.rb}

@@ -1,85 +1,80 @@
-
-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)
-    if value.is_a?(Hash)
-      value.to_hash_with_indifferent_access
-    elsif value.is_a?(Array)
-      value.map!{|item| item.is_a?(Hash) || item.is_a?(Array) ? HashWithIndifferentAccess.convert_value(item) : item }
-    else
-      value
-    end
-  end
-
-  def inspect
-    super
-  end
-
-  def to_s
-    super
-  end
-
-  protected
-
-  def copy_from(original)
-    original.each do |key, value|
-      self[key] = self.class.convert_value(value)
-    end
-  end
-end
-
-
-class Hash
-  def to_hash_with_indifferent_access
-    return HashWithIndifferentAccess.new(self)
-  end
-
-  def to_s
-    if @filtered
-      return self.dup.filter!.inspect
-    else
-      super
-    end
-  end
-
-  def filtered!
-    @filtered = true
-    self.keys.each do |key|
-      self[key].filtered! if self[key].is_a?(Hash)
-    end
-    return self
-  end
-
-  def filter!
-    filters = Fleck.config.filters
-    self.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
-
-    return self
-  end
-end
+# 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

data/lib/fleck/utilities/host_rating.rb

@@ -0,0 +1,104 @@
+# 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
+  end
+
+  private
+
+  # 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

data/lib/fleck/version.rb

@@ -1,3 +1,6 @@
-module Fleck
-  VERSION = "1.0.1"
-end
+# frozen_string_literal: true
+
+# Open `Fleck` module to set `VERSION` constant.
+module Fleck
+  VERSION = '2.0.0'
+end

data/lib/fleck.rb

@@ -1,72 +1,81 @@
-require "logger"
-require "rainbow"
-require "rainbow/ext/string"
-require "bunny"
-require "thread_safe"
-require "securerandom"
-require "oj"
-require "ztimer"
-require "fleck/version"
-require "fleck/hash_with_indifferent_access"
-require "fleck/loggable"
-require "fleck/host_rating"
-require "fleck/configuration"
-require "fleck/consumer"
-require "fleck/client"
-
-module Fleck
-  @config      = Configuration.new
-  @consumers   = ThreadSafe::Array.new
-  @connections = ThreadSafe::Hash.new
-
-  def self.configure
-    yield @config if block_given?
-    @config
-  end
-
-  def self.logger
-    @config.logger
-  end
-
-  def self.register_consumer(consumer_class)
-    unless @consumers.include?(consumer_class)
-      @consumers << consumer_class
-    end
-  end
-
-  def self.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
-    return conn
-  end
-
-  def self.terminate
-    @connections.each do |key, connection|
-      begin
-        Fleck.logger.info "Closing connection #{key}"
-        connection.close
-      rescue => e
-        Fleck.logger.error e.inspect
-      end
-    end
-    @connections.clear
-
-    true
-  end
-
-  private
-
-  class << self
-    attr_reader :config
-  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 :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