liebre 0.1.21 → 0.2.1

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/liebre.rb

@@ -1,24 +1,35 @@
 require "liebre/version"
-require "bunny"
+
+require "liebre/adapter"
+require "liebre/config"
+
+require "liebre/bridge"
+require "liebre/actor"
+require "liebre/engine"
+
+require "liebre/runner"
 
 module Liebre
-  
-  autoload :Common,            'liebre/common'
-  autoload :Config,            'liebre/config'
-  autoload :ConnectionManager, 'liebre/connection_manager'
-  autoload :Publisher,         'liebre/publisher'
-  autoload :Runner,            'liebre/runner'
-  
+
+  def self.start only: nil
+    runner = Runner.new(engine: Liebre.engine)
+    runner.run(only: only)
+  end
+
   def self.config
     @config ||= Config.new
   end
-  
-  def self.env
-    Config.env
+
+  def self.engine
+    @engine ||= Engine.new(config)
   end
-  
-  def self.logger
-    Config.logger
+
+  def self.repo
+    engine.repo
   end
-  
-end
+
+  def self.configure
+    yield(config)
+  end
+
+end

data/lib/liebre/actor.rb

@@ -0,0 +1,11 @@
+require "liebre/actor/context"
+
+require "liebre/actor/publisher"
+require "liebre/actor/consumer"
+require "liebre/actor/rpc/client"
+require "liebre/actor/rpc/server"
+
+module Liebre
+  module Actor
+  end
+end

data/lib/liebre/actor/consumer.rb

@@ -0,0 +1,80 @@
+require 'concurrent'
+
+require 'liebre/actor/consumer/resources'
+require 'liebre/actor/consumer/callback'
+require 'liebre/actor/consumer/core'
+require 'liebre/actor/consumer/reporter'
+
+module Liebre
+  module Actor
+    class Consumer
+      include Concurrent::Async
+
+      OPTS = {:block => false, :manual_ack => true}
+
+      def initialize context
+        super()
+
+        @context = context
+      end
+
+      def start() async.__start__(); end
+      def stop()  async.__stop__();  end
+
+      def consume(info, meta, payload) async.__consume__(info, meta, payload); end
+
+      def ack(info, opts = {})    async.__ack__(info, opts);     end
+      def nack(info, opts = {})   async.__nack__(info, opts);    end
+      def reject(info, opts = {}) async.__reject__(info, opts);  end
+      def failed(info, error)     async.__failed__(info, error); end
+
+      def clean() async.__clean__(); end
+
+      def __start__
+        reporter.on_start { core.start }
+      end
+      def __stop__
+        reporter.on_stop { core.stop }
+      end
+
+      def __consume__ info, meta, payload
+        reporter.on_consume { core.consume(info, meta, payload) }
+      end
+
+      def __ack__(info, opts)
+        reporter.on_ack { core.ack(info, opts) }
+      end
+      def __nack__(info, opts)
+        reporter.on_nack { core.nack(info, opts) }
+      end
+      def __reject__(info, opts)
+        reporter.on_reject { core.reject(info, opts) }
+      end
+
+      def __failed__(info, error)
+        reporter.on_failed(error) { core.failed(info, error) }
+      end
+
+      def __clean__
+        reporter.on_clean { core.clean() }
+      end
+
+    private
+
+      def core
+        @core ||= Core.new(self, resources, context, Callback)
+      end
+
+      def resources
+        Resources.new(context)
+      end
+
+      def reporter
+        @reporter ||= Reporter.new(context)
+      end
+
+      attr_reader :context
+
+    end
+  end
+end

data/lib/liebre/actor/consumer/callback.rb

@@ -0,0 +1,34 @@
+module Liebre
+  module Actor
+    class Consumer
+      class Callback
+
+        def initialize consumer, info
+          @consumer = consumer
+          @info     = info
+        end
+
+        def ack opts = {}
+          consumer.ack(info, opts)
+        end
+
+        def nack opts = {}
+          consumer.nack(info, opts)
+        end
+
+        def reject opts = {}
+          consumer.reject(info, opts)
+        end
+
+        def failed error
+          consumer.failed(info, error)
+        end
+
+      private
+
+        attr_reader :consumer, :info
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/consumer/core.rb

@@ -0,0 +1,80 @@
+module Liebre
+  module Actor
+    class Consumer
+      class Core
+
+        OPTS = {:block => false, :manual_ack => true}
+
+        def initialize consumer, resources, context, callback_class
+          @consumer       = consumer
+          @resources      = resources
+          @context        = context
+          @callback_class = callback_class
+        end
+
+        def start
+          queue.subscribe(OPTS) do |info, meta, payload|
+            consumer.consume(info, meta, payload)
+          end
+          dead_queue
+        end
+
+        def stop
+          chan.close
+        end
+
+        def consume info, meta, payload
+          callback = callback_class.new(consumer, info)
+
+          handler.call(payload, meta, callback) do |error|
+            callback.failed(error)
+          end
+        end
+
+        def ack(info, opts)    queue.ack(info, opts);    end
+        def nack(info, opts)   queue.nack(info, opts);   end
+        def reject(info, opts) queue.reject(info, opts); end
+
+        def failed info, error
+          queue.reject(info, {})
+        end
+
+        def clean
+          queue.delete
+          exchange.delete
+          dead_queue.delete
+          dead_exchange.delete
+        end
+
+      private
+
+        def queue
+          resources.queue
+        end
+
+        def exchange
+          resources.exchange
+        end
+
+        def dead_queue
+          resources.dead_queue
+        end
+
+        def dead_exchange
+          resources.dead_exchange
+        end
+
+        def chan
+          context.chan
+        end
+
+        def handler
+          context.handler
+        end
+
+        attr_reader :consumer, :resources, :context, :callback_class
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/consumer/reporter.rb

@@ -0,0 +1,84 @@
+module Liebre
+  module Actor
+    class Consumer
+      class Reporter
+
+        def initialize context
+          @context = context
+        end
+
+        def on_start
+          yield
+          logger.info("Consumer started: #{name}")
+        rescue Exception => error
+          logger.error("Error starting consumer: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_stop
+          yield
+          logger.info("Consumer stopped: #{name}")
+        rescue Exception => error
+          logger.error("Error stopping consumer: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_consume
+          yield
+        rescue Exception => error
+          logger.error("Error consuming: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_ack
+          yield
+        rescue Exception => error
+          logger.error("Error acking: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_nack
+          yield
+        rescue Exception => error
+          logger.error("Error nacking: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_reject
+          yield
+        rescue Exception => error
+          logger.error("Error rejecting: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_failed error
+          logger.error("Error on Consumer when handling a message #{name}\n#{error.message}\n#{error.backtrace}")
+          yield
+        rescue Exception => error
+          logger.error("Error handling consumer handler failure: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_clean
+          yield
+        rescue Exception => error
+          logger.error("Error cleaning consumer: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+      private
+
+        def name
+          @name ||= context.name.inspect
+        end
+
+        def logger
+          @logger ||= context.logger
+        end
+
+        attr_reader :context
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/consumer/resources.rb

@@ -0,0 +1,47 @@
+require 'liebre/actor/consumer/resources/config'
+
+module Liebre
+  module Actor
+    class Consumer
+      class Resources
+
+        def initialize context
+          @context = context
+        end
+
+        def queue
+          @queue ||= declare.queue(config.queue).tap do |queue|
+            declare.bind(queue, exchange, config.bind)
+          end
+        end
+
+        def exchange
+          @exchange ||= declare.exchange(config.exchange)
+        end
+
+        def dead_queue
+          @dead_queue ||= declare.queue(config.dead_queue).tap do |queue|
+            declare.bind(queue, dead_exchange)
+          end
+        end
+
+        def dead_exchange
+          @dead_exchange ||= declare.exchange(config.dead_exchange)
+        end
+
+      private
+
+        def declare
+          context.declare
+        end
+
+        def config
+          @config ||= Config.new(context.spec)
+        end
+
+        attr_reader :context
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/consumer/resources/config.rb

@@ -0,0 +1,65 @@
+module Liebre
+  module Actor
+    class Consumer
+      class Resources
+        class Config
+
+          def initialize spec
+            @spec = spec
+          end
+
+          def queue
+            raw_queue.merge(:opts => dead_letter_opts)
+          end
+
+          def exchange
+            raw_exchange
+          end
+
+          def bind
+            spec.fetch(:bind, {})
+          end
+
+          def dead_queue
+            {:name => error_name,
+             :opts => raw_queue.fetch(:opts, {})}
+          end
+
+          def dead_exchange
+            {:name => error_name,
+             :type => "fanout",
+             :opts => raw_exchange.fetch(:opts, {})}
+          end
+
+        private
+
+          def dead_letter_opts
+            raw_queue.fetch(:opts, {}).dup.tap do |opts|
+              opts[:arguments] = opts.
+                fetch(:arguments, {}).
+                merge("x-dead-letter-exchange" => error_name)
+            end
+          end
+
+          def error_name
+            @error_name ||= begin
+              raw_name = spec.fetch(:queue).fetch(:name)
+              "#{raw_name}-error"
+            end
+          end
+
+          def raw_exchange
+            spec.fetch(:exchange)
+          end
+
+          def raw_queue
+            spec.fetch(:queue)
+          end
+
+          attr_reader :spec
+
+        end
+      end
+    end
+  end
+end