liebre 0.1.21 → 0.2.1

data/lib/liebre/actor/context.rb

@@ -0,0 +1,40 @@
+require "liebre/actor/context/declare"
+require "liebre/actor/context/handler"
+
+module Liebre
+  module Actor
+    class Context
+
+      attr_reader :chan, :name, :opts
+
+      def initialize chan, name, opts, config
+        @chan = chan
+        @name = name
+        @opts = opts
+
+        @config = config
+      end
+
+      def spec
+        opts.fetch(:resources, {})
+      end
+
+      def declare
+        @declare ||= Declare.new(chan)
+      end
+
+      def handler
+        @handler ||= Handler.new(opts)
+      end
+
+      def logger
+        config.logger
+      end
+
+    private
+
+      attr_reader :config
+
+    end
+  end
+end

data/lib/liebre/actor/context/declare.rb

@@ -0,0 +1,44 @@
+module Liebre
+  module Actor
+    class Context
+      class Declare
+
+        def initialize chan
+          @chan = chan
+        end
+
+        def default_exchange
+          chan.default_exchange
+        end
+
+        def exchange config
+          name = config.fetch(:name)
+          type = config.fetch(:type)
+          opts = config.fetch(:opts, {})
+
+          chan.exchange(name, type, opts)
+        end
+
+        def queue config
+          name = config.fetch(:name)
+          opts = config.fetch(:opts, {})
+
+          chan.queue(name, opts)
+        end
+
+        def bind queue, exchange, config = {}
+          all_opts = [config].flatten
+
+          all_opts.each do |opts|
+            queue.bind(exchange, opts)
+          end
+        end
+
+      private
+
+        attr_reader :chan
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/context/handler.rb

@@ -0,0 +1,44 @@
+require 'concurrent'
+
+module Liebre
+  module Actor
+    class Context
+      class Handler
+
+        DEFAULT_POOL_SIZE = 5
+
+        def initialize opts
+          @opts = opts
+        end
+
+        def call *args, &block
+          pool.post { handle(args, block) }
+        end
+
+      private
+
+        def handle args, block
+          handler = handler_class.new(*args)
+          handler.call
+        rescue => error
+          block.call(error)
+        end
+
+        def pool
+          @pool ||= begin
+            size = opts.fetch(:pool_size, DEFAULT_POOL_SIZE)
+
+            Concurrent::FixedThreadPool.new(size)
+          end
+        end
+
+        def handler_class
+          @handler_class ||= opts.fetch(:handler)
+        end
+
+        attr_reader :opts
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/publisher.rb

@@ -0,0 +1,58 @@
+require 'concurrent'
+
+require 'liebre/actor/publisher/resources'
+require 'liebre/actor/publisher/core'
+require 'liebre/actor/publisher/reporter'
+
+module Liebre
+  module Actor
+    class Publisher
+      include Concurrent::Async
+
+      def initialize context
+        super()
+
+        @context = context
+      end
+
+      def start() async.__start__(); end
+      def stop()  async.__stop__();  end
+
+      def publish(payload, opts = {}) async.__publish__(payload, opts); end
+
+      def clean() async.__clean__(); end
+
+      def __start__
+        reporter.on_start { core.start }
+      end
+      def __stop__
+        reporter.on_stop { core.stop }
+      end
+
+      def __publish__ payload, opts
+        reporter.on_publish { core.publish(payload, opts) }
+      end
+
+      def __clean__
+        reporter.on_clean { core.clean() }
+      end
+
+    private
+
+      def core
+        @core ||= Core.new(resources, context)
+      end
+
+      def resources
+        Resources.new(context)
+      end
+
+      def reporter
+        @reporter ||= Reporter.new(context)
+      end
+
+      attr_reader :context
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Liebre
+  module Actor
+    class Publisher
+      class Core
+
+        def initialize resources, context
+          @resources = resources
+          @context   = context
+        end
+
+        def start
+          exchange
+        end
+
+        def stop
+          chan.close
+        end
+
+        def publish payload, opts
+          exchange.publish(payload, opts)
+        end
+
+        def clean
+          exchange.delete
+        end
+
+      private
+
+        def exchange
+          resources.exchange
+        end
+
+        def chan
+          context.chan
+        end
+
+        attr_reader :resources, :context
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Liebre
+  module Actor
+    class Publisher
+      class Reporter
+
+        def initialize context
+          @context = context
+        end
+
+        def on_start
+          yield
+          logger.info("Publisher started: #{name}")
+        rescue Exception => error
+          logger.error("Error starting publisher: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_publish
+          yield
+        rescue Exception => error
+          logger.error("Error publising: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_stop
+          yield
+          logger.info("Publisher stopped: #{name}")
+        rescue Exception => error
+          logger.error("Error stopping publisher: #{name}\n#{error.message}\n#{error.backtrace}")
+          raise error
+        end
+
+        def on_clean
+          yield
+        rescue Exception => error
+          logger.error("Error cleaning publisher: #{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/publisher/resources.rb

@@ -0,0 +1,33 @@
+module Liebre
+  module Actor
+    class Publisher
+      class Resources
+
+        def initialize context
+          @context = context
+        end
+
+        def exchange
+          @exchange ||= declare.exchange(exchange_config)
+        end
+
+      private
+
+        def exchange_config
+          spec.fetch(:exchange)
+        end
+
+        def spec
+          context.spec
+        end
+
+        def declare
+          context.declare
+        end
+
+        attr_reader :context
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/rpc/client.rb

@@ -0,0 +1,88 @@
+require 'concurrent'
+
+require 'liebre/actor/rpc/client/resources'
+require 'liebre/actor/rpc/client/pending'
+require 'liebre/actor/rpc/client/task'
+require 'liebre/actor/rpc/client/core'
+require 'liebre/actor/rpc/client/reporter'
+
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        include Concurrent::Async
+
+        TIMEOUT = 5
+
+        def initialize context
+          super()
+
+          @context = context
+        end
+
+        def start() async.__start__(); end
+        def stop()  async.__stop__();  end
+
+        def request payload, opts = {}, timeout = TIMEOUT
+          call_ivar     = await.__request__(payload, opts, timeout)
+          response_ivar = call_ivar.value
+
+          response_ivar.value(timeout)
+        end
+        def reply(meta, response) async.__reply__(meta, response); end
+
+        def expire() async.__expire__(); end
+
+        def clean() async.__clean__(); end
+
+        def __start__()
+          reporter.on_start { core.start }
+        end
+        def __stop__()
+          reporter.on_stop { core.stop }
+        end
+
+        def __request__(payload, opts, timeout)
+          reporter.on_request { core.request(payload, opts, timeout) }
+        end
+
+        def __reply__(meta, response)
+          reporter.on_reply { core.reply(meta, response) }
+        end
+
+        def __expire__()
+          reporter.on_expire { core.expire() }
+        end
+
+        def __clean__()
+          reporter.on_clean { core.clean() }
+        end
+
+      private
+
+        def core
+          @core ||= Core.new(self, resources, context, pending, task)
+        end
+
+        def resources
+          Resources.new(context)
+        end
+
+        def pending
+          Pending.new
+        end
+
+        def task
+          Task.new
+        end
+
+        def reporter
+          @reporter ||= Reporter.new(context)
+        end
+
+        attr_reader :context
+
+      end
+    end
+  end
+end

data/lib/liebre/actor/rpc/client/core.rb

@@ -0,0 +1,75 @@
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        class Core
+
+          OPTS            = {:block => false, :manual_ack => false}
+          EXPIRE_INTERVAL = 60
+
+          def initialize client, resources, context, pending, task
+            @client    = client
+            @resources = resources
+            @context   = context
+            @pending   = pending
+            @task      = task
+          end
+
+          def start
+            response_queue.subscribe(OPTS) do |_info, meta, payload|
+              client.reply(meta, payload)
+            end
+            request_exchange
+
+            task.every(EXPIRE_INTERVAL) { client.expire }
+          end
+
+          def stop
+            task.cancel_all
+            chan.close
+          end
+
+          def request payload, opts, timeout
+            r = pending.add(timeout) do |correlation_id|
+              opts = opts.merge :reply_to       => response_queue.name,
+                                :correlation_id => correlation_id
+
+              request_exchange.publish(payload, opts)
+              context.logger.info("request pending - correlation_id: #{correlation_id}")
+            end
+          end
+
+          def reply meta, response
+            pending.finish(meta.correlation_id, response)
+          end
+
+          def expire
+            pending.expire()
+          end
+
+          def clean
+            request_exchange.delete
+            response_queue.delete
+          end
+
+        private
+
+          def response_queue
+            resources.response_queue
+          end
+
+          def request_exchange
+            resources.request_exchange
+          end
+
+          def chan
+            context.chan
+          end
+
+          attr_reader :client, :resources, :context, :pending, :task
+
+        end
+      end
+    end
+  end
+end