bbk-app 1.0.0.72899

data/lib/bbk/app/handler.rb

@@ -0,0 +1,69 @@
+module BBK
+  module App
+    class Handler
+
+      def initialize(&block)
+        @handlers = {}
+        @default = if block_given?
+          block
+        else
+          lambda do |*_args|
+            # delivery_info, properties, body = message
+          end
+        end
+      end
+
+      # регистрация обработчика
+      # тип матчера, парметры матчера, Обработчик | Класс обработчика, [аргументы обработчика]
+      def register(*args, **kwargs, &block)
+        type, rule, callable = nil
+
+        if args.first.respond_to?(:rule)
+          type, *rule = args.first.rule
+        elsif args.first.is_a?(Symbol) || args.first.is_a?(String)
+          type = args.shift.to_sym
+          rule = args.shift
+          if rule.nil?
+            $logger&.warn("Not found processor rule in positional arguments. Use keyword arguments #{kwargs} as rule")
+            rule = kwargs
+            kwargs = {}
+          end
+          raise "rule is not a Hash: #{args.inspect}" unless rule.is_a?(Hash)
+        else
+          raise "type and rule or method :rule missing: #{args.inspect}"
+        end
+        args.push block if block_given?
+
+        callable = if args.first.is_a?(Class)
+          BBK::App::Factory.new(*args, **kwargs)
+        elsif args.first.respond_to?(:call)
+          args.first
+        else
+          raise "callable object or class missing: #{args.inspect}"
+        end
+
+        matcher = BBK::App::Matchers.create(type, *[rule].flatten)
+        @handlers.each do |m, _c|
+          $logger&.warn("Handler with same matcher already registered: #{m.inspect}") if m == matcher
+        end
+
+        @handlers[BBK::App::Matchers.create(type, *[rule].flatten)] = callable
+      end
+
+      def default(&block)
+        @default = block
+      end
+
+      def match(metadata, payload, delivery_info)
+        @handlers.each_with_object([nil, @default]) do |p, _res|
+          m, h = p
+          if (match = m.match(metadata, payload, delivery_info))
+            return [match, h]
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/bbk/app/matchers/base.rb

@@ -0,0 +1,50 @@
+module BBK
+  module App
+    module Matchers
+      class Base
+
+        attr_reader :rule
+
+        def hash
+          (self.class.to_s + rule.to_s).hash
+        end
+
+        def ==(other)
+          self.class == other.class && rule == other.rule
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def keys_deep(data)
+          data.inject([]) do |res, p|
+            k, _v = p
+            res.push k
+            res += keys_deep(data[k]) if data[k].is_a? Hash
+            res
+          end
+        end
+
+        def match_impl(rule, data)
+          result = rule.each_with_object({}.with_indifferent_access) do |p, res|
+            k, v = p
+
+            if v == :any && data.key?(k.to_sym)
+              res[k.to_sym] = data[k.to_sym]
+            elsif v.is_a? Hash
+              res[k.to_sym] = match_impl(v, data[k.to_sym] || {})
+            elsif v == data[k.to_sym]
+              res[k.to_sym] = data[k.to_sym]
+            end
+          end
+
+          result.keys.size == rule.keys.size && keys_deep(result).count >= keys_deep(rule).count ? result : nil
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/matchers/delivery_info.rb

@@ -0,0 +1,35 @@
+require 'bbk/app/matchers/base'
+
+module BBK
+  module App
+    module Matchers
+      class DeliveryInfo < Base
+
+
+        def initialize(rule)
+          @rule = rule.with_indifferent_access
+        end
+
+        def match(_headers, _payload, delivery_info, *_args)
+          delivery_info = delivery_info.to_hash unless delivery_info.is_a? Hash
+          match_impl(@rule, delivery_info.with_indifferent_access)
+        rescue StandardError
+          nil
+        end
+
+        def match_impl(rule, data)
+          result = super
+          if !result && (key_rule = rule[:routing_key])
+            regexp_rule = Regexp.new("\\A#{key_rule.gsub('.', '\.').gsub('*', '\S+').gsub('#',
+                                                                                          '.*')}\\Z")
+            check = regexp_rule.match?(data[:routing_key])
+            result = ({ 'routing_key' => data[:routing_key] } if check)
+          end
+          result
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/matchers/full.rb

@@ -0,0 +1,41 @@
+require 'bbk/app/matchers/headers'
+require 'bbk/app/matchers/payload'
+require 'bbk/app/matchers/delivery_info'
+
+module BBK
+  module App
+    module Matchers
+      class Full < Base
+
+        def initialize(*args)
+          if args.size == 1
+            arg = args[0]
+            hrule = arg.fetch(:headers, {})
+            prule = arg.fetch(:payload, {})
+            drule = arg.fetch(:delivery_info, {})
+          else
+            hrule, prule, drule = *args
+          end
+
+          @hm = Headers.new(hrule)
+          @pm = Payload.new(prule)
+          @dm = DeliveryInfo.new(drule)
+          @rule = [hrule, prule, drule]
+        end
+
+        def match(headers, payload, delivery_info, *_args)
+          return unless (hr = @hm.match(headers, payload, delivery_info))
+          return unless (pr = @pm.match(headers, payload, delivery_info))
+          return unless (dr = @dm.match(headers, payload, delivery_info))
+
+          [hr, pr, dr]
+        rescue StandardError
+          nil
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/matchers/headers.rb

@@ -0,0 +1,23 @@
+require 'bbk/app/matchers/base'
+
+module BBK
+  module App
+    module Matchers
+      class Headers < Base
+
+        def initialize(rule)
+          @rule = rule.with_indifferent_access
+        end
+
+        def match(headers, _payload = nil, _delivery_info = nil, *_args)
+          match_impl(@rule, headers.with_indifferent_access)
+        rescue StandardError
+          nil
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/matchers/payload.rb

@@ -0,0 +1,23 @@
+require 'bbk/app/matchers/base'
+
+module BBK
+  module App
+    module Matchers
+      class Payload < Base
+
+        def initialize(rule)
+          @rule = rule.with_indifferent_access
+        end
+
+        def match(_headers, payload, _delivery_info = nil, *_args)
+          payload = JSON(payload) if payload&.is_a?(String)
+          match_impl(@rule, payload.with_indifferent_access)
+        rescue StandardError
+          nil
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/matchers.rb

@@ -0,0 +1,28 @@
+require 'bbk/app/matchers/headers'
+require 'bbk/app/matchers/payload'
+require 'bbk/app/matchers/delivery_info'
+require 'bbk/app/matchers/full'
+
+module BBK
+  module App
+    module Matchers
+
+      def self.create(type, *args)
+        case type
+        when :meta, :headers
+          Headers.new(args.first)
+        when :payload
+          Payload.new(args.first)
+        when :delivery, :delivery_info
+          DeliveryInfo.new(args.first)
+        when :full
+          Full.new(*args)
+        else
+          raise "there is no such matcher: #{type}"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/bbk/app/middlewares/active_record_pool.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require 'bbk/app/middlewares/base'
+
+module BBK
+  module App
+    module Middlewares
+      class ActiveRecordPool < Base
+
+
+        def call(msg)
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            app.call(msg)
+          end
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/middlewares/base.rb

@@ -0,0 +1,20 @@
+module BBK
+  module App
+    module Middlewares
+      class Base
+
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(_msg)
+          raise 'Middleware not implemented!'
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/middlewares/from_block.rb

@@ -0,0 +1,26 @@
+module BBK
+  module App
+    module Middlewares
+      class FromBlock < Base
+
+        def initialize(&block)
+          raise ArgumentError.new('Not passed block') unless block_given?
+
+          @block = block
+        end
+
+        def build(app)
+          @app = app
+          self
+        end
+
+        def call(msg)
+          @block.call(app, msg)
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/middlewares/self_killer.rb

@@ -0,0 +1,66 @@
+module BBK
+  module App
+    module Middlewares
+      class SelfKiller
+
+
+        SELF_KILLER_LOG_INTERVAL = 300
+
+        attr_reader :dispatcher, :count, :threshold, :stop_time
+
+        def initialize(dispatcher, delay: 10 * 60, threshold: 10_000, logger: ::Logger.new(STDOUT))
+          @dispatcher = dispatcher
+          @threshold = threshold
+          @count = 0
+          @stop_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay
+          @stopping = false
+          @logger = logger
+          @logger.info "[SelfKiller] Initializing: #{@count}/#{@threshold}"
+          reset_log_timer
+        end
+
+        def build(app)
+          @app = app
+          self
+        end
+
+        def call(msg)
+          @count += 1
+          if time_exceed?(@log_timer)
+            @logger.info "[SelfKiller] Threshold status: #{@count}/#{@threshold}, delayed: #{!time_exceed?}"
+            reset_log_timer
+          end
+          close_dispatcher if stop?
+
+          @app.call(msg)
+        end
+
+        protected
+
+          def reset_log_timer
+            @log_timer = Process.clock_gettime(Process::CLOCK_MONOTONIC) + SELF_KILLER_LOG_INTERVAL
+          end
+
+          def stop?
+            !@stopping && threshold_exceed? && time_exceed?
+          end
+
+          def threshold_exceed?
+            @count > @threshold
+          end
+
+          def time_exceed?(time = @stop_time)
+            Process.clock_gettime(Process::CLOCK_MONOTONIC) > time
+          end
+
+          def close_dispatcher
+            @stopping = true
+            @logger.warn '[SelfKiller] Threshold exceeded, closing dispatcher...'
+            Thread.new { @dispatcher.close } # Don't block current call
+          end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/middlewares/watchdog.rb

@@ -0,0 +1,78 @@
+module BBK
+  module App
+    module Middlewares
+      class Watchdog < Base
+
+        attr_reader :publisher, :route, :message_factory, :reply_to, :delay, :timeout,
+                    :watcher_delay, :pinger_thread, :watcher_thread
+
+        def initialize(publisher, route, message_factory, reply_to, delay: 20, timeout: 60, watcher_delay: 40)
+          @publisher = publisher
+          @route = route
+          @message_factory = message_factory
+          @reply_to = reply_to
+          @delay = delay
+          @timeout = timeout
+          @timestamp = Time.now.to_i
+          @watcher_delay = watcher_delay
+        end
+
+        def build(app)
+          @app = app
+          self
+        end
+
+        def call(msg)
+          touch
+          @app.call(msg)
+        end
+
+        def start
+          touch
+          start_ping
+          start_watch
+          self
+        end
+
+        def stop
+          @pinger_thread&.kill
+          @watcher_thread&.kill
+        end
+
+        protected
+
+          def start_ping
+            @pinger_thread = Thread.new(publisher, delay, route) do |publisher, delay, route|
+              Thread.current.name = 'WatchDog::Pinger'
+              loop do
+                publisher.publish BBK::App::Dispatcher::Result.new(
+                  route,
+                  message_factory.build(reply_to)
+                )
+                sleep delay
+              end
+            end
+          end
+
+          def start_watch
+            @watcher_thread = Thread.new(timeout, watcher_delay) do |timeout, watcher_delay|
+              Thread.current.name = 'WatchDog::Watcher'
+              msg = "[CRITICAL] watchdog: last ping is more than #{timeout} seconds ago"
+
+              sleep watcher_delay while (Time.now.to_i - @timestamp) < timeout
+              warn msg
+              exit!(8)
+            end
+          end
+
+          def touch
+            @timestamp = Time.now.to_i
+          end
+
+
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/middlewares.rb

@@ -0,0 +1,12 @@
+require 'bbk/app/middlewares/base'
+require 'bbk/app/middlewares/from_block'
+require 'bbk/app/middlewares/watchdog'
+require 'bbk/app/middlewares/self_killer'
+
+module BBK
+  module App
+    module Middlewares
+    end
+  end
+end
+

data/lib/bbk/app/processors/base.rb

@@ -0,0 +1,46 @@
+require 'bbk/utils/proxy_logger'
+
+module BBK
+  module App
+    module Processors
+      class Base
+
+        attr_reader :logger
+
+        def initialize(*untyped, logger: BBK::App.logger, **)
+          logger = logger.respond_to?(:tagged) ? logger : ActiveSupport::TaggedLogging.new(logger)
+          @logger = BBK::Utils::ProxyLogger.new(logger, tags: self.class.to_s)
+        end
+
+        def rule
+          unless self.class.respond_to?(:rule)
+            raise NotImplementedError.new("Not implemented class method rule in #{self.class.name}")
+          end
+
+          self.class.rule
+        end
+
+        def call(message, results: [])
+          debug 'processing message...'
+
+          process(message, results: results)
+
+          results
+        end
+
+        def process(_message, results: [])
+          raise NotImplementedError.new("process method abstract in Processor class. Results count: #{results.count}")
+        end
+
+
+        %i[debug info warn error fatal unknown].each do |severity|
+          define_method(severity) do |*args|
+            logger.public_send(severity, *args)
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/processors/ping.rb

@@ -0,0 +1,26 @@
+require 'bbk/app/processors/base'
+
+module BBK
+  module App
+    module Processors
+      class Ping < Base
+
+        def initialize(pong_message_factory, pong_route, *args, **kwargs)
+          super
+          @pong_message_factory = pong_message_factory
+          @pong_route = pong_route
+        end
+
+        def process(message, results: [])
+          results << BBK::App::Dispatcher::Result.new(
+            @pong_route,
+            @pong_message_factory.build(message)
+          )
+          results
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/processors/pong.rb

@@ -0,0 +1,16 @@
+require 'bbk/app/processors/ping'
+
+module BBK
+  module App
+    module Processors
+      class Pong < Base
+
+        def process(*)
+          logger.debug 'Process Pong message'
+        end
+
+      end
+    end
+  end
+end
+

data/lib/bbk/app/processors.rb

@@ -0,0 +1,3 @@
+require 'bbk/app/processors/ping'
+require 'bbk/app/processors/pong'
+

data/lib/bbk/app/proxy_logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BBK
+  module App
+    class ProxyLogger
+
+      attr_reader :tags, :logger
+
+      def initialize(logger, tags:)
+        @logger = logger
+        @tagged = @logger.respond_to?(:tagged)
+        @tags = [tags].flatten
+      end
+
+      def add_tags(*tags)
+        @tags += tags.flatten
+        @tags = @tags.uniq
+      end
+
+      def method_missing(method, *args, &block)
+        super unless logger.respond_to?(method)
+
+        if @tagged
+          current_tags = tags - logger.formatter.current_tags
+          logger.tagged(current_tags) { logger.send(method, *args, &block) }
+        else
+          logger.send(method, *args, &block)
+        end
+      end
+
+      def respond_to?(*args)
+        logger.send(:respond_to?, *args) || super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        logger.send(:respond_to_missing?, method_name, include_private) || super
+      end
+
+    end
+  end
+end
+