fleck 1.0.1 → 2.1.2

data/lib/fleck/consumer.rb

@@ -1,287 +1,7 @@
-
-module Fleck
-  class Consumer
-    class << self
-      attr_accessor :logger, :configs, :actions_map, :consumers, :initialize_block
-    end
-
-    def self.inherited(subclass)
-      super
-      init_consumer(subclass)
-      autostart(subclass)
-      Fleck.register_consumer(subclass)
-    end
-
-    def self.configure(opts = {})
-      self.configs.merge!(opts)
-      logger.debug "Consumer configurations updated."
-    end
-
-    def self.actions(*args)
-      args.each do |item|
-        case item
-        when Hash
-          item.each do |k,v|
-            self.register_action(k.to_s, v.to_s)
-          end
-        else
-          self.register_action(item.to_s, item.to_s)
-        end
-      end
-    end
-
-    def self.register_action(action, method_name)
-      raise ArgumentError.new("Cannot use `:#{method_name}` method as an action, because it is reserved for Fleck::Consumer internal stuff!") if Fleck::Consumer.instance_methods.include?(method_name.to_s.to_sym)
-      self.actions_map[action.to_s] = method_name.to_s
-    end
-
-    def self.initialize(&block)
-      self.initialize_block = block
-    end
-
-    def self.start(block: false)
-      self.consumers.each do |consumer|
-        consumer.start(block: block)
-      end
-    end
-
-    def self.init_consumer(subclass)
-      subclass.logger          = Fleck.logger.clone
-      subclass.logger.progname = subclass.to_s
-
-      subclass.logger.debug "Setting defaults for #{subclass.to_s.color(:yellow)} consumer"
-
-      subclass.configs     = Fleck.config.default_options
-      subclass.configs[:autostart] = true if subclass.configs[:autostart].nil?
-      subclass.actions_map = {}
-      subclass.consumers   = []
-    end
-
-    def self.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
-
-    def initialize(thread_id = nil)
-      @__thread_id    = thread_id
-      @__connection   = nil
-      @__consumer_tag = nil
-      @__request      = nil
-      @__response     = nil
-      @__lock         = Mutex.new
-      @__lounger      = ConditionVariable.new
-
-      @__host          = configs[:host]
-      @__port          = configs[:port]
-      @__user          = configs[:user]          || 'guest'
-      @__pass          = configs[:password]      || configs[:pass]
-      @__vhost         = configs[:vhost]         || "/"
-      @__exchange_type = configs[:exchange_type] || :direct
-      @__exchange_name = configs[:exchange_name] || ""
-      @__queue_name    = configs[:queue]
-      @__autostart     = configs[:autostart]
-      @__prefetch      = (configs[:prefetch]      || 100).to_i
-      @__mandatory     = !!configs[:mandatory]
-
-      if self.class.initialize_block
-        self.instance_eval(&self.class.initialize_block)
-      end
-
-      logger.info "Launching #{self.class.to_s.color(:yellow)} consumer ..."
-
-      start if @__autostart
-
-      at_exit do
-        terminate
-      end
-    end
-
-    def start(block: false)
-      connect!
-      create_channel!
-      subscribe!
-      @__lock.synchronize{ @__lounger.wait(@__lock) } if block
-    end
-
-    def on_message(request, response)
-      method_name = actions[request.action.to_s]
-      if method_name
-        self.send(method_name)
-      else
-        response.not_found
-      end
-    end
-
-    def terminate
-      @__lock.synchronize { @__lounger.signal }
-      pause
-      unless channel.nil? || channel.closed?
-        channel.close
-        logger.info "Consumer successfully terminated."
-      end
-    end
-
-    def logger
-      return @logger if @logger
-      @logger = self.class.logger.clone
-      @logger.progname = "#{self.class.name}" + (configs[:concurrency].to_i <= 1 ? "" : "[#{@__thread_id}]")
-
-      @logger
-    end
-
-    def configs
-      @configs ||= self.class.configs
-    end
-
-    def actions
-      @actions ||= self.class.actions_map
-    end
-
-    def connection
-      return @__connection
-    end
-
-    def channel
-      return @__channel
-    end
-
-    def queue
-      return @__queue
-    end
-
-    def exchange
-      return @__exchange
-    end
-
-    def publisher
-      return @__publisher
-    end
-
-    def subscription
-      return @__subscription
-    end
-
-    def pause
-      if subscription
-        cancel_ok = subscription.cancel
-        @__consumer_tag = cancel_ok.consumer_tag
-      end
-    end
-
-    def resume
-      subscribe!
-    end
-
-    def request
-      @__request
-    end
-
-    def response
-      @__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! if @__response
-    end
-
-    protected
-
-    def connect!
-      @__connection = Fleck.connection(host: @__host, port: @__port, user: @__user, pass: @__pass, vhost: @__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"
-      @__channel  = @__connection.create_channel
-      @__channel.prefetch(@__prefetch) # consume messages in batches
-      @__publisher = Bunny::Exchange.new(@__connection.create_channel, :direct, 'fleck')
-      if @__exchange_type == :direct && @__exchange_name == ""
-        @__queue = @__channel.queue(@__queue_name, auto_delete: false)
-      else
-        @__exchange  = Bunny::Exchange.new(@__channel, @__exchange_type, @__exchange_name)
-        @__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
-
-      @__subscription = @__queue.subscribe(options) do |delivery_info, metadata, payload|
-        started_at = Time.now.to_f
-        @__response = Fleck::Consumer::Response.new(metadata.correlation_id)
-        begin
-          @__request  = Fleck::Consumer::Request.new(metadata, payload, delivery_info)
-          if @__request.errors.empty?
-            on_message(@__request, @__response)
-          else
-            @__response.status = @__request.status
-            @__response.errors += @__request.errors
-          end
-        rescue => e
-          logger.error e.inspect + "\n" + e.backtrace.join("\n")
-          @__response.status = 500
-          @__response.errors << 'Internal Server Error'
-        end
-
-        if @__response.rejected?
-          @__channel.reject(delivery_info.delivery_tag, @__response.requeue?)
-        else
-          logger.debug "Sending response: #{@__response}"
-          if @__channel.closed?
-            logger.warn "Channel already closed! The response #{metadata.correlation_id} is going to be dropped."
-          else
-            @__publisher.publish(@__response.to_json, routing_key: metadata.reply_to, correlation_id: metadata.correlation_id, mandatory: @__mandatory)
-            @__channel.ack(delivery_info.delivery_tag)
-          end
-        end
-
-        exec_time  = ((Time.now.to_f - started_at) * 1000).round(2)
-        ex_type    = @__exchange_type.to_s[0].upcase
-        ex_name    = @__exchange_name.to_s == "" ? "".inspect : @__exchange_name
-        status     = @__response.status
-        status     = 406 if @__response.rejected?
-        status     = 503 if @__channel.closed?
-
-        message    = "#{@__request.ip} #{metadata[:app_id]} => "
-        message   += "(#{@__exchange_name.to_s.inspect}|#{ex_type}|#{@__queue_name}) "
-        message   += "##{@__request.id} \"#{@__request.action} /#{@__request.version || 'v1'}\" #{status} "
-        message   += "(#{exec_time}ms) #{'DEPRECATED!' if @__response.deprecated?}"
-
-        if status >= 500
-          logger.error message
-        elsif status >= 400 || @__response.deprecated?
-          logger.warn message
-        else
-          logger.info message
-        end
-      end
-    end
-
-    def restart!
-      create_channel!
-      subscribe!
-    end
-  end
-end
-
-require "fleck/consumer/request"
-require "fleck/consumer/response"
+# 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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      # Stores data about an action parameter, which will be used for automatic parameters validation.
+      class ActionParam
+        AVAILABLE_TYPES = %w[string number boolean object array].freeze
+        TYPE_ALIASES = {
+          'text' => 'string',
+          'integer' => 'number',
+          'float' => 'number',
+          'hash' => 'object'
+        }.freeze
+
+        attr_reader :name, :type, :options
+
+        def initialize(name, type, options = {})
+          @name = name
+          @type = type
+          @options = options
+
+          check_options!
+        end
+
+        def string?
+          @type == 'string'
+        end
+
+        def required?
+          options[:required]
+        end
+
+        def validate(value)
+          Validation.new(name, type, value, options)
+        end
+
+        private
+
+        def check_options!
+          check_type!
+          check_required!
+          check_default!
+          check_min_max!
+          check_format!
+          check_clamp!
+        end
+
+        def check_type!
+          @type = @type.to_s.strip.downcase
+
+          @type = TYPE_ALIASES[@type] unless TYPE_ALIASES[@type].nil?
+
+          valid_type = AVAILABLE_TYPES.include?(@type)
+          raise "Invalid param type: #{@type.inspect}" unless valid_type
+        end
+
+        def check_required!
+          options[:required] = (options[:required] == true)
+        end
+
+        def check_default!
+          return if options[:default].nil?
+
+          # TODO: check default value type
+        end
+
+        def check_min_max!
+          check_min!
+          check_max!
+
+          return if options[:min].nil? || options[:max].nil?
+
+          raise 'Invalid min-max range' unless options[:min] <= options[:max]
+        end
+
+        def check_min!
+          min = options[:min]
+          return if min.nil?
+
+          raise 'Invalid minimum' unless min.is_a?(Integer) || min.is_a?(Float)
+        end
+
+        def check_max!
+          max = options[:max]
+          return if max.nil?
+
+          raise 'Invalid maximum' unless max.is_a?(Integer) || max.is_a?(Float)
+        end
+
+        def check_format!
+          return if options[:format].nil?
+
+          raise 'Invalid format' unless options[:format].is_a?(Regexp)
+        end
+
+        def check_clamp!
+          return if options[:clamp].nil?
+
+          raise 'Invalid clamp' unless options[:clamp].is_a?(Array)
+          raise 'Invalid clamp range' unless options[:clamp].first.to_i < options[:clamp].last.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      # `Fleck::Core::Consumer::Actions` module implements the logic for consumer actions
+      # registration, so that this information could be used when a request is received.
+      # This mechanism will allow to process the request with the appropriate consumer method.
+      module Actions
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `Actions` module is imported.
+        module ClassMethods
+          attr_accessor :actions_map
+
+          def actions(*args)
+            args.each do |item|
+              case item
+              when Hash then item.each { |k, v| register_action(k.to_s, v.to_s) }
+              else register_action(item.to_s, item.to_s)
+              end
+            end
+          end
+
+          def register_action(action, method_name, options = {})
+            if Fleck::Consumer.instance_methods.include?(method_name.to_s.to_sym)
+              raise ArgumentError, "Cannot use `:#{method_name}` method as an action, " \
+                                    'because it is reserved for Fleck::Consumer internal stuff!'
+            end
+
+            options[:method_name] = method_name.to_s
+            options[:params] ||= {}
+            actions_map[action.to_s] = options
+          end
+        end
+
+        # Defines instance methods to import when `Actions` module is imported.
+        module InstanceMethods
+          def actions
+            @actions ||= self.class.actions_map
+          end
+
+          protected
+
+          def execute_action!
+            action_name = request.action.to_s
+            action = actions[action_name]
+            unless action
+              request.log_headers_and_params!
+              message = "Action #{action_name.inspect} not found!"
+              not_found! error: message, body: [
+                { type: 'action', name: action_name, value: action_name, error: 'not_found', message: message }
+              ]
+            end
+
+            # iterate over action params and use param options to validate incoming request params.
+            action[:params].each { |_, param| validate_action_param!(param) }
+
+            request.log_headers_and_params!
+            send(action[:method_name])
+          end
+
+          def validate_action_param!(param)
+            validation = param.validate(request.params[param.name])
+            unless validation.valid?
+              request.log_headers_and_params!
+              bad_request! error: "Invalid param value: #{param.name} = #{validation.value.inspect}",
+                           body: validation.errors
+            end
+            request.params[param.name] = validation.value
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,69 @@
+module Fleck
+  module Core
+    class Consumer
+      module Configuration
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `Configuration` module is imported.
+        module ClassMethods
+          attr_accessor :configs
+
+          def configure(opts = {})
+            configs.merge!(opts)
+            logger.debug 'Consumer configurations updated.'
+          end
+        end
+
+        # Defines instance methods to import when `Configuration` module is imported.
+        module InstanceMethods
+          def configs
+            @configs ||= self.class.configs
+          end
+
+          def rmq_host
+            @rmq_host ||= configs[:host]
+          end
+
+          def rmq_port
+            @rmq_port ||= configs[:port]
+          end
+
+          def rmq_user
+            @rmq_user ||= configs.fetch(:user, 'guest')
+          end
+
+          def rmq_pass
+            @rmq_pass ||= configs.fetch(:password, configs[:pass])
+          end
+
+          def rmq_vhost
+            @rmq_vhost ||= configs.fetch(:vhost, '/')
+          end
+
+          def queue_name
+            @queue_name ||= configs[:queue]
+          end
+
+          def rmq_exchange_type
+            @rmq_exchange_type ||= configs.fetch(:exchange_type, :direct)
+          end
+
+          def rmq_exchange_name
+            @rmq_exchange_name ||= configs.fetch(:exchange_name, '')
+          end
+
+          def ack_mandatory?
+            @ack_mandatory ||= !configs[:mandatory].nil?
+          end
+
+          def prefetch_size
+            @prefetch_size ||= configs.fetch(:prefetch, 100).to_i
+          end
+        end
+      end
+    end
+  end
+end