bbk-app 1.0.0.72899

data/lib/bbk/app/thread_pool.rb

@@ -0,0 +1,75 @@
+require 'timeouter'
+
+module BBK
+  module App
+    class ThreadPool
+
+      attr_reader :jobs, :threads
+
+      def initialize(size, queue: 10)
+        @jobs = SizedQueue.new(queue)
+        @shutdown = false
+        @term = false
+
+        @threads = size.times.map do
+          Thread.new(@jobs) do |jobs|
+            begin
+              Thread.current.report_on_exception = true
+              Thread.current.abort_on_exception = true
+
+              unless @shutdown
+                until @term
+                  job, args = jobs.pop
+                  break if  @term || job == :exit
+
+                  job.call(*args)
+                end
+              end
+            rescue StandardError => e
+              warn "[CRITICAL]: ThreadPool exception: #{e}"
+              warn "[CRITICAL]: #{e.backtrace.join("\n")}"
+              # Thread.main.raise e
+              exit(1)
+            end
+          end
+        end
+      end
+
+      def post(*args, &block)
+        @jobs << [block, args] unless @shutdown
+      end
+
+      def shutdown
+        return if @shutdown
+
+        @shutdown = true
+        Thread.new { @threads.size.times { @jobs.push(:exit) } }
+      end
+
+      def wait_for_termination(timeout = 0)
+        Timeouter.run(timeout) do |t|
+          @threads.all? do |thread|
+            thread.join(t.left)
+          end
+        end
+      end
+
+      alias wait wait_for_termination
+
+      def kill(timeout = 1)
+        return if @term
+
+        @term = true
+        shutdown
+        if wait_for_termination(timeout)
+          true
+        else
+          @threads.each(&:kill)
+          false
+        end
+      end
+
+    end
+  end
+end
+

data/lib/bbk/app/version.rb

@@ -0,0 +1,8 @@
+module BBK
+  module App
+
+    VERSION = '1.0.0'
+
+  end
+end
+

data/lib/bbk/app.rb

@@ -0,0 +1,23 @@
+require 'bbk/app/version'
+require 'bbk/app/factory'
+require 'bbk/app/handler'
+require 'bbk/app/matchers'
+require 'bbk/app/middlewares'
+require 'bbk/app/dispatcher'
+require 'bbk/app/processors'
+require 'bbk/utils/logger'
+
+module BBK
+  module App
+
+    class << self
+
+      attr_accessor :logger
+
+    end
+
+    self.logger = BBK::Utils::Logger.default
+
+  end
+end
+

data/sig/bbk/app/callable.rbs

@@ -0,0 +1,3 @@
+interface _Callable
+  def call: (*untyped, **untyped) -> untyped
+end

data/sig/bbk/app/dispatcher/message.rbs

@@ -0,0 +1,33 @@
+module BBK
+  module App
+    class Dispatcher
+      interface _Message
+        def headers: () -> Hash[String|Symbol, untyped]
+        def payload: () -> Hash[untyped, untyped]?
+      end
+
+      interface _Mapping
+        def []: (untyped) -> untyped
+        def []=: (untyped, untyped) -> untyped
+      end
+
+      interface _IncomingMessage
+        include _Message
+        def delivery_info: () -> untyped
+        def body: () -> String
+
+        def ack: (*untyped, ?answer: Result?, **untyped) -> void
+        def nack: (*untyped, ?error: untyped, **untyped) -> void
+        def message_id: () -> String
+      end
+
+
+      class Message
+        include _IncomingMessage
+
+        def initialize: (_Consumer, untyped?, Hash[String|Symbol, untyped], untyped, *untyped) -> void
+
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher/message_stream.rbs

@@ -0,0 +1,15 @@
+module BBK
+  module App
+    class Dispatcher
+      class MessageStream
+
+        def initialize: (?size: Integer) -> void
+        def push: (_Message) -> void
+        def each: () -> Enumerator[_IncomingMessage|Symbol, void]
+                      | {(_IncomingMessage) -> void} -> void
+        def close: () -> void        
+
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher/queue_stream_strategy.rbs

@@ -0,0 +1,12 @@
+module BBK
+  module App
+    class Dispatcher
+      class QueueStreamStrategy
+        include _StreamStrategy
+
+        def initialize: (untyped, logger: _Logger|BBK::Utils::ProxyLogger) -> void
+ 
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher/result.rbs

@@ -0,0 +1,12 @@
+module BBK
+  module App
+    class Dispatcher
+      class Result
+        attr_accessor route: Route
+        attr_accessor message: _Message
+        
+        def initialize: (String|Route route, _Message message) -> void
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher/route.rbs

@@ -0,0 +1,18 @@
+module BBK
+  module App
+    class Dispatcher
+      class Route
+        attr_reader uri: ::URI::Generic
+        attr_reader scheme: String?
+        attr_reader domain: String?
+        attr_reader routing_key: String
+
+        def initialize: (String|::URI::Generic) -> void 
+
+        def to_s: () -> String
+        def ==: (untyped) -> bool
+
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher/stream_strategy.rbs

@@ -0,0 +1,13 @@
+module BBK
+  module App
+    class Dispatcher
+      interface _StreamStrategy
+        def run: (Array[_Consumer]) {(_Message) -> void} -> void
+      end
+
+      class StreamStrategyClass
+        def new: (*untyped, **untyped) -> _StreamStrategy
+      end
+    end
+  end
+end

data/sig/bbk/app/dispatcher.rbs

@@ -0,0 +1,62 @@
+module BBK
+  module App
+    class Dispatcher
+
+      ANSWER_DOMAIN: 'answer'
+
+      interface _Consumer
+        def stop: () -> void
+      end
+
+      interface _Publisher
+        def publish: (Result) -> untyped # Concurrent::Promises::ResolvableFuture
+        def close: () -> void
+      end
+
+      interface _Middleware
+        def call: (_Message) -> Array[Result]
+      end
+
+      interface _MiddlewareClass
+        def new: (untyped) -> _Middleware
+      end
+
+      interface _MiddlewareBuilder
+        def build: (untyped) -> _Middleware
+      end
+
+      interface _ProcessorsStack
+        def call: (_Message) -> Array[Result]
+      end
+
+      interface _PoolFactory
+        def call: (Integer pool_size, Integer queue_size) -> untyped
+      end
+
+      type logger = BBK::Utils::_ProxyObject|_Logger
+
+      attr_accessor force_quit: bool
+      attr_reader consumers: Array[_Consumer]
+      attr_reader publishers: Array[_Publisher]
+      attr_reader middlewares: Array[_MiddlewareBuilder|_MiddlewareClass]
+      attr_reader logger: logger
+
+      def initialize: (Handler, ?pool_size: Integer, ?logger: logger, ?pool_factory: _PoolFactory, ?stream_strategy: StreamStrategyClass) -> void
+      def register_consumer: (_Consumer) -> void
+      def register_publisher: (_Publisher) -> void
+      def register_middleware: (_MiddlewareBuilder|_MiddlewareClass) -> void
+      def run: () -> void
+      def close: (?Integer time) -> void
+
+      private
+
+      def process: (_Message) -> void
+      def process_message: (_Message) -> Array[Result]
+      def find_processor: (_Message) -> [untyped, _Processor]
+      def build_processing_stack: () -> _ProcessorsStack
+      def send_results: (_Message, Array[untyped]) -> void
+      def publish_result: (Result) -> untyped
+
+    end
+  end
+end

data/sig/bbk/app/factory.rbs

@@ -0,0 +1,21 @@
+module BBK
+  module App
+    class Factory
+
+      interface _ArgFactory
+        def new: (*untyped, **untyped) -> untyped
+      end
+
+      attr_accessor klass: _ArgFactory
+      attr_accessor instanceargs: Array[untyped]
+      attr_accessor instancekwargs: Hash[Symbol, untyped]
+    
+      def initialize: (_ArgFactory, *untyped) -> void
+      
+      def create: () -> _Callable
+
+      def call: (*untyped) -> void
+
+    end
+  end
+end

data/sig/bbk/app/handler.rbs

@@ -0,0 +1,19 @@
+module BBK
+  module App
+    class Handler
+      @handlers: Hash[BBK::App::Matchers::_Matcher, _Callable]
+      @default: untyped
+
+      type hashKey = String | Symbol
+
+      def initialize: () ?{() -> void} -> void
+
+      def register: (*untyped, **untyped) ?{() -> void} -> void
+
+      def default: () {()->void} -> void
+
+      def match: (Hash[hashKey, untyped] metadata, Hash[hashKey, untyped] payload, Hash[hashKey, untyped] delivery_info) -> Array[untyped]?
+
+    end
+  end
+end

data/sig/bbk/app/matchers.rbs

@@ -0,0 +1,12 @@
+module BBK
+  module App
+    module Matchers
+
+      interface _Matcher
+        def match: (Hash[String|Symbol, untyped], Hash[String|Symbol, untyped], Hash[String|Symbol, untyped], *untyped) -> boolish
+      end
+
+      def self.create: (Symbol|String, *untyped) -> _Matcher
+    end
+  end
+end

data/sig/bbk/app/middlewares/self_killer.rbs

@@ -0,0 +1,26 @@
+module BBK
+  module App
+    module Middlewares
+      class SelfKiller
+
+        attr_reader dispatcher: untyped
+        attr_reader count: Integer
+        attr_reader threshold: Integer
+        attr_reader stop_time: Integer|Float
+
+        def initialize: (untyped, ?delay: Integer, ?threshold: Integer, ?logger: _Logger) -> void
+        def build: (untyped) -> void
+        def call: (untyped) -> void  
+          
+        private
+
+        def reset_log_time: () -> void
+        def stop?: () -> void
+        def threshold_exceed?: () -> bool
+        def time_exceed?: (?Float) -> bool
+        def close_dispatcher: () -> void
+
+      end
+    end
+  end
+end

data/sig/bbk/app/middlewares/watchdog.rbs

@@ -0,0 +1,40 @@
+module BBK
+  module App
+    module Middlewares
+      class Watchdog
+
+        interface _App
+          def call: (untyped) -> untyped
+        end
+
+        interface _MessageFactory
+          def build: (String) -> BBK::App::Dispatcher::_Message
+        end
+
+        attr_reader publisher: untyped
+        attr_reader route: String
+        attr_reader message_factory: _MessageFactory
+        attr_reader reply_to: String
+        attr_reader delay: Integer
+        attr_reader timeout: Integer
+        attr_reader watched_delay: Integer
+        attr_reader pinger_thread: Thread?
+        attr_reader watched_thread: Thread?
+
+        def initialize: (untyped, String, _MessageFactory, String, ?delay: Integer, ?timeout: Integer, ?watcher_delay: Integer) -> void
+
+        def build: (_App) -> void
+        def call:(BBK::App::Dispatcher::_Message) -> Array[BBK::App::Dispatcher::Result]
+        def start: () -> void
+        def stop: () -> void
+        
+        private
+
+        def start_ping: () -> void
+        def start_watch: () -> void
+        def touch: () -> void
+
+      end
+    end
+  end
+end

data/sig/bbk/app/processors/base.rbs

@@ -0,0 +1,21 @@
+module BBK
+  module App
+
+    interface _Processor
+      def call: (BBK::App::Dispatcher::_Message message, ?results: Array[BBK::App::Dispatcher::Result]) -> void
+    end
+
+    module Processors
+      class Base
+        
+        include _Processor
+        type processorLogger = _Logger | BBK::Utils::ProxyLogger 
+
+        attr_reader logger: processorLogger
+        def initialize: (*untyped, ?logger: processorLogger, **untyped) -> void
+        def rule: () -> untyped
+        def process: (BBK::App::Dispatcher::_Message message, ?results: Array[BBK::App::Dispatcher::Result]) -> void  
+      end
+    end
+  end
+end