fleck 0.7.0 → 2.1.0

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      # `Decorators` module implements the feature which allows to use decorators for action methods.
+      # This will provide a easier and cleaner way to define consumer actions
+      module Decorators
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `Decorators` module is imported.
+        module ClassMethods
+          def method_added(name)
+            super(name)
+
+            # Register method as action `action` or `action_name` decorator has been used
+            method_options[:action_name] && register_action(method_options[:action_name], name, method_options)
+
+            # Reset method options after method has been added
+            reset_method_options!
+          end
+
+          def method_options
+            @method_options ||= default_method_options
+          end
+
+          def default_method_options
+            {
+              action_name: nil,
+              description: nil,
+              params: {}.to_hash_with_indifferent_access,
+              headers: {}.to_hash_with_indifferent_access
+            }
+          end
+
+          def reset_method_options!
+            @method_options = nil
+          end
+
+          def action(name, description = nil)
+            action_name(name)
+            desc(description)
+          end
+
+          def desc(description)
+            method_options[:description] = description if description
+          end
+
+          def param(name, options = {})
+            method_options[:params][name] = ActionParam.new(name, options[:type], options)
+          end
+
+          def header(name, options = {})
+            raise 'Not Implemented'
+            # method_options[:headers][name] = ActionParam.new(name, options[:type], options)
+          end
+
+          protected
+
+          def action_name(name)
+            valid = name.is_a?(String) || name.is_a?(Symbol)
+            valid or raise(ArgumentError, "Invalid action name type: #{name.class}, String or Symbol expected!")
+
+            method_options[:action_name] = name
+          end
+        end
+
+        # Defines instance methods to import when `Decorators` module is imported.
+        module InstanceMethods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Fleck
+  module Core
+    class Consumer
+      module HelpersDefiners
+        INTERRUPT_NAME = :terminate_execution
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `HelpersDefilers` module is imported.
+        module ClassMethods
+          def error_method(name, code, message)
+            define_method(name) do |error: nil, body: nil, interrupt: true|
+              response.render_error(code, [message] + [error].flatten)
+              response.body = body
+              throw INTERRUPT_NAME if interrupt
+            end
+          end
+
+          def redirect_method(name, code)
+            success_method(name, code)
+          end
+
+          def success_method(name, code)
+            define_method(name) do |body = nil, interrupt: true|
+              response.status = code
+              response.body = body
+              throw INTERRUPT_NAME if interrupt
+            end
+          end
+
+          def information_method(name, code)
+            success_method(name, code)
+          end
+        end
+
+        # Defines instance methods to import when `HelpersDefilers` module is imported.
+        module InstanceMethods
+          def halt(code, body = nil, errors = nil)
+            response.body = body
+            if code >= 400
+              response.render_error(code, [errors].flatten)
+            else
+              response.status = code
+            end
+
+            throw INTERRUPT_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      module Logger
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        # Defines class methods to import when `Logger` module is imported.
+        module ClassMethods
+          attr_accessor :logger
+        end
+
+        # Defines instance methods to import when `Logger` module is imported.
+        module InstanceMethods
+          def logger
+            return @logger if @logger
+
+            @logger = self.class.logger.clone
+            @logger.progname = self.class.name.to_s + (configs[:concurrency].to_i <= 1 ? '' : "[#{consumer_id}]")
+
+            @logger
+          end
+
+          private
+
+          def log_request
+            status = final_response_status
+            message = log_formatted_message
+
+            if status >= 500
+              logger.error message
+            elsif status >= 400 || response.deprecated?
+              logger.warn message
+            else
+              logger.info message
+            end
+          end
+
+          def exchange_type_code
+            rmq_exchange_type.to_s[0].upcase
+          end
+
+          def final_response_status
+            return 406 if request.rejected?
+            return 503 if channel.closed?
+
+            response.status
+          end
+
+          def log_formatted_message
+            [
+              request_origin,
+              exchange_and_queue_name,
+              request_metadata,
+              request_execution_time,
+              deprecation_message
+            ].join
+          end
+
+          def request_origin
+            "#{request.ip} #{request.app_id} => "
+          end
+
+          def exchange_and_queue_name
+            ex_name = rmq_exchange_name.to_s == '' ? ''.inspect : rmq_exchange_name
+            "(#{ex_name}|#{exchange_type_code}|#{queue_name}) "
+          end
+
+          def request_metadata
+            "##{request.id} \"#{request.action} /#{request.version || 'v1'}\" #{final_response_status} "
+          end
+
+          def request_execution_time
+            "(#{request.execution_time}ms)"
+          end
+
+          def deprecation_message
+            response.deprecated? ? ' DEPRECATED' : ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      class Request
+        include Fleck::Loggable
+
+        attr_reader :id, :response, :metadata, :payload, :action, :data, :headers, :version, :ip, :params, :status, :errors,
+                    :delivery_tag, :app_id, :reply_to, :created_at, :processed_at
+
+        def initialize(metadata, payload, delivery_info)
+          @created_at      = Time.now
+          @id              = metadata.correlation_id
+          logger.progname += " #{@id}"
+
+          @response      = Fleck::Core::Consumer::Response.new(metadata.correlation_id)
+          @metadata      = metadata
+          @app_id        = metadata[:app_id]
+          @reply_to      = @metadata.reply_to
+          @payload       = payload
+          @exchange      = delivery_info.exchange
+          @queue         = delivery_info.routing_key
+          @delivery_tag  = delivery_info.delivery_tag
+          @data          = {}
+          @headers       = (@metadata.headers || {}).to_hash_with_indifferent_access
+          @action        = @metadata.type
+          @version       = nil
+          @ip            = nil
+          @params        = {}
+          @failed        = false
+          @rejected      = false
+          @requeue       = false
+
+          parse_request!
+        end
+
+        def processed!
+          @processed_at = Time.now
+        end
+
+        def execution_time
+          ((@processed_at.to_f - @created_at.to_f) * 1000).round(2)
+        end
+
+        def failed?
+          @failed
+        end
+
+        def reject!(requeue: false)
+          @rejected = true
+          @requeue  = requeue
+          processed!
+        end
+
+        def rejected?
+          @rejected
+        end
+
+        def requeue?
+          @requeue
+        end
+
+        def log_headers_and_params!
+          queue_name = "(#{@exchange == '' ? @queue : "#{@queue}@#{@exchange}"})".color(:red)
+          endpoint = "/#{action} :#{@version || 'v1'}".color(:red)
+          message = "\n" \
+                    "#{ip} - #{queue_name} #{endpoint} [#{@id}]\n" \
+                    "  ~ headers ~ #{headers.inspect.color(:green)}\n" \
+                    "  @params #{params.inspect.color(:green)}"
+          logger.debug message
+        end
+
+        protected
+
+        def parse_request!
+          @data = Oj.load(@payload, mode: :compat).to_hash_with_indifferent_access.filtered!
+          @headers.merge!(@data['headers'] || {}).filtered!
+
+          logger.debug "Request (exchange: #{@exchange.inspect}, queue: #{@queue.inspect}, " \
+                       "options: #{@headers}, message: #{@data})"
+
+          @action            ||= @headers['action']
+          @headers['action'] ||= @action
+          @version             = @headers['version']
+          @ip                  = @headers['ip']
+          @params              = @data['params'] || {}
+        rescue Oj::ParseError => e
+          log_error(e)
+          response.render_error(400, 'Bad request', e.inspect)
+          @failed = true
+        rescue StandardError => e
+          log_error(e)
+          response.render_error(500, 'Internal Server Error', e.inspect)
+          @failed = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+
+module Fleck
+  module Core
+    class Consumer
+      class Response
+        include Fleck::Loggable
+
+        attr_accessor :id, :status, :errors, :headers, :body
+
+        def initialize(request_id)
+          @id = request_id
+          logger.progname += " #{@id}"
+
+          @status     = 200
+          @errors     = []
+          @headers    = {}
+          @body       = nil
+          @deprecated = false
+        end
+
+        def errors?
+          !@errors.empty?
+        end
+
+        def deprecated!
+          @deprecated = true
+        end
+
+        def deprecated?
+          @deprecated
+        end
+
+        def not_found(msg = nil)
+          @status = 404
+          @errors << 'Resource Not Found'
+          @errors << msg if msg
+        end
+
+        def render_error(status, msg = [])
+          raise ArgumentError, "Invalid status code: #{status.inspect}" unless (400..599).cover?(status.to_i)
+
+          @status = status.to_i
+          if msg.is_a?(Array)
+            @errors += msg
+          else
+            @errors << msg
+          end
+
+          @errors.compact!
+        end
+
+        def to_json(filter: false)
+          data = {
+            "status"     => @status,
+            "errors"     => @errors,
+            "headers"    => @headers,
+            "body"       => @body,
+            "deprecated" => @deprecated
+          }
+          data.filter! if filter
+
+          return Oj.dump(data, mode: :compat)
+        rescue => e
+          logger.error e.inspect + "\n" + e.backtrace.join("\n")
+          return Oj.dump({
+            "status" => 500,
+            "errors" => ['Internal Server Error', 'Failed to dump the response to JSON']
+          }, mode: :compat)
+        end
+
+        def to_s
+          return "#<#{self.class} #{self.to_json(filter: true)}>"
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Fleck
+  module Core
+    class Consumer
+      class Validation
+        attr_reader :value, :errors
+
+        def initialize(name, type, value, options = {})
+          @name = name
+          @type         = type
+          @value        = value || options[:default]
+          @required     = (options[:required] == true)     # default: trues
+          @allow_blank  = (options[:allow_blank] != false) # default: false
+          @min          = options[:min]
+          @max          = options[:max]
+          @clamp        = options[:clamp] || [-Float::INFINITY, Float::INFINITY]
+
+          @errors = []
+
+          validate!
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        def required?
+          @required
+        end
+
+        def add_error(error_type, message)
+          @errors << { type: 'param', name: @name, value: @value, error: error_type, message: message }
+        end
+
+        private
+
+        def validate!
+          case @type
+          when 'string'  then validate_string!
+          when 'number'  then validate_number!
+          when 'boolean' then validate_boolean!
+          when 'hash'    then validate_hash!
+          when 'array'   then validate_array!
+          end
+        end
+
+        def validate_string!
+          # if value is required, check for value presence
+          required? && check_if_present!
+
+          # don't go further if value is nil
+          return if value.nil?
+
+          # check if value is a string
+          check_if_string!
+
+          # check string format
+          check_format!
+        end
+
+        def validate_number!
+          # if value is required, check for value presence
+          required? && check_if_present!
+
+          # don't go further if value is nil
+          return if value.nil?
+
+          # check if value is a number
+          check_if_number!
+
+          # check if number is between min and max
+          check_min_max!
+
+          # Check if value is within specified clamping range, and correct if necessary
+          check_clamp!
+        end
+
+        def validate_boolean!
+          # if value is required, check for value presence
+          required? && check_if_present!
+
+          return if value.nil?
+
+          # check if value is a boolean
+          check_if_boolean!
+        end
+
+        def check_if_present!
+          if value.nil? || (!@allow_blank && value.to_s.strip == '')
+            add_error(:blank, "#{@name} cannot be blank")
+            return false
+          end
+
+          true
+        end
+
+        def check_if_string!
+          return true if value.is_a?(String)
+
+          @value = @value.to_s
+
+          true
+        end
+
+        def check_if_number!
+          return true if value.is_a?(Integer) || value.is_a?(Float)
+
+          if value.is_a?(String) && numeric?
+            @value = value.to_f
+            @value = value.to_i if value.modulo(1).zero?
+
+            return true
+          end
+
+          add_error(:type, "#{@name} has invalid type: #{@type} expected")
+
+          false
+        end
+
+        def check_if_boolean!
+          return true if [true, false].any?(value)
+
+          if value.is_a?(String) && boolean?
+            @value = %w[t true y yes].any?(value.strip.downcase)
+            return true
+          end
+
+          add_error(:type, "#{@name} has invalid type: #{@type} expected")
+
+          false
+        end
+
+        def check_format!
+          return true if @format.nil?
+
+          add_error(:format, "#{@name} has invalid format") if value.match(@format).nil?
+
+          true
+        end
+
+        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
+        end
+
+        def check_clamp!
+          @value = @value.clamp(@clamp.first || -Float::INFINITY, @clamp.last || Float::INFINITY)
+        end
+
+        def numeric?
+          !Float(value).nil?
+        rescue ArgumentError
+          false
+        end
+
+        def boolean?
+          %w[t true y yes f false n no].any?(value.strip.downcase)
+        end
+      end
+    end
+  end
+end