liebre 0.1.21 → 0.2.1

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

@@ -0,0 +1,65 @@
+require 'concurrent'
+require 'securerandom'
+
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        class Pending
+
+          Request = Struct.new(:ivar, :expiration_time)
+
+          def initialize
+            @pending = {}
+          end
+
+          def add timeout
+            new_ivar.tap do |ivar|
+              correlation_id = new_correlation_id()
+              yield(correlation_id)
+
+              store(correlation_id, ivar, timeout)
+            end
+          end
+
+          def finish correlation_id, response
+            pending.delete(correlation_id).tap do |request|
+              request.ivar.set(response) if request
+            end
+          end
+
+          def expire
+            now = current_time
+
+            pending.delete_if do |_correlation_id, request|
+              now > request.expiration_time
+            end
+          end
+
+        private
+
+          def store correlation_id, ivar, timeout
+            expiration_time = current_time + timeout
+
+            pending[correlation_id] = Request.new(ivar, expiration_time)
+          end
+
+          def new_correlation_id
+            SecureRandom.urlsafe_base64
+          end
+
+          def new_ivar
+            Concurrent::IVar.new
+          end
+
+          def current_time
+            Time.now
+          end
+
+          attr_reader :pending
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        class Reporter
+
+          def initialize context
+            @context = context
+          end
+
+          def on_start
+            yield
+            logger.info("RPC client started: #{name}")
+          rescue Exception => error
+            logger.error("Error starting RPC client: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_stop
+            yield
+            logger.info("RPC client stopped: #{name}")
+          rescue Exception => error
+            logger.error("Error stopping RPC client: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_request
+            yield
+          rescue Exception => error
+            logger.error("Error performing request: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_reply
+            yield
+          rescue Exception => error
+            logger.error("Error receiving request reply: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_expire
+            yield
+          rescue Exception => error
+            logger.error("Error expiring RPC client pending requests: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_clean
+            yield
+          rescue Exception => error
+            logger.error("Error cleaning RPC client: #{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
+end

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

@@ -0,0 +1,62 @@
+require 'securerandom'
+
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        class Resources
+
+          DEFAULT_PREFIX = "rpc_responses"
+
+          QUEUE_OPTS = {:auto_delete => true,
+                        :exclusive   => true,
+                        :durable     => false}
+
+          def initialize context
+            @context = context
+          end
+
+          def response_queue
+            @response_queue ||= declare.queue(:name => queue_name, :opts => QUEUE_OPTS)
+          end
+
+          def request_exchange
+            @request_exchange ||= declare.exchange(exchange_config)
+          end
+
+        private
+
+          def queue_name
+            prefix = queue_config.fetch(:prefix, DEFAULT_PREFIX)
+            suffix = SecureRandom.urlsafe_base64
+
+            "#{prefix}_#{suffix}"
+          end
+
+          def exchange_config
+            spec.fetch(:exchange)
+          end
+
+          def queue_config
+            spec.fetch(:queue, {})
+          end
+
+          def bind_config
+            spec.fetch(:bind, {})
+          end
+
+          def spec
+            context.spec
+          end
+
+          def declare
+            context.declare
+          end
+
+          attr_reader :context
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'concurrent'
+
+module Liebre
+  module Actor
+    module RPC
+      class Client
+        class Task
+
+          def initialize
+            @tasks = []
+          end
+
+          def every interval, &block
+            task = Concurrent::TimerTask.new(execution_interval: interval, &block)
+            tasks << task
+
+            task.execute
+          end
+
+          def cancel_all
+            tasks.each(&:shutdown)
+            tasks.clear
+          end
+
+        private
+
+          attr_reader :tasks
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'concurrent'
+
+require 'liebre/actor/rpc/server/resources'
+require 'liebre/actor/rpc/server/callback'
+require 'liebre/actor/rpc/server/core'
+require 'liebre/actor/rpc/server/reporter'
+
+module Liebre
+  module Actor
+    module RPC
+      class Server
+        include Concurrent::Async
+
+        OPTS = {:block => false, :manual_ack => false}
+
+        def initialize context
+          super()
+
+          @context = context
+        end
+
+        def start() async.__start__(); end
+        def stop()  async.__stop__();  end
+
+        def handle(meta, payload) async.__handle__(meta, payload); end
+
+        def reply(meta, response, opts = {}) async.__reply__(meta, response, opts); end
+        def failed(meta, error)              async.__failed__(meta, error);         end
+
+        def clean() async.__clean__(); end
+
+        def __start__()
+          reporter.on_start { core.start }
+        end
+        def __stop__()
+          reporter.on_stop { core.stop }
+        end
+
+        def __handle__(meta, payload)
+          reporter.on_handle { core.handle(meta, payload) }
+        end
+
+        def __reply__(meta, response, opts)
+          reporter.on_reply { core.reply(meta, response, opts) }
+        end
+
+        def __failed__(meta, error)
+          reporter.on_failed(error) { core.failed(meta, 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
+end

data/lib/liebre/actor/rpc/server/callback.rb

@@ -0,0 +1,28 @@
+module Liebre
+  module Actor
+    module RPC
+      class Server
+        class Callback
+
+          def initialize server, meta
+            @server = server
+            @meta   = meta
+          end
+
+          def reply response, opts = {}
+            server.reply(meta, response, opts)
+          end
+
+          def failed error
+            server.failed(meta, error)
+          end
+
+        private
+
+          attr_reader :server, :meta
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Liebre
+  module Actor
+    module RPC
+      class Server
+        class Core
+          include Concurrent::Async
+
+          OPTS = {:block => false, :manual_ack => false}
+
+          def initialize server, resources, context, callback_class
+            @server         = server
+            @resources      = resources
+            @context        = context
+            @callback_class = callback_class
+          end
+
+          def start
+            queue.subscribe(OPTS) do |info, meta, payload|
+              server.handle(meta, payload)
+            end
+            exchange
+          end
+
+          def stop
+            chan.close
+          end
+
+          def handle meta, payload
+            callback = callback_class.new(server, meta)
+
+            handler.call(payload, meta, callback) do |error|
+              callback.failed(error)
+            end
+          end
+
+          def reply meta, response, opts = {}
+            opts = opts.merge :routing_key    => meta.reply_to,
+                              :correlation_id => meta.correlation_id
+
+            exchange.publish(response, opts)
+          end
+
+          def failed meta, error
+          end
+
+          def clean
+            queue.delete
+            exchange.delete
+          end
+
+        private
+
+          def queue
+            resources.request_queue
+          end
+
+          def exchange
+            resources.response_exchange
+          end
+
+          def chan
+            context.chan
+          end
+
+          def handler
+            context.handler
+          end
+
+          attr_reader :server, :resources, :context, :callback_class
+
+        end
+      end
+    end
+  end
+end

data/lib/liebre/actor/rpc/server/reporter.rb

@@ -0,0 +1,72 @@
+module Liebre
+  module Actor
+    module RPC
+      class Server
+        class Reporter
+
+          def initialize context
+            @context = context
+          end
+
+          def on_start
+            yield
+            logger.info("RPC server started: #{name}")
+          rescue Exception => error
+            logger.error("Error starting RPC server: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_stop
+            yield
+            logger.info("RPC server stopped: #{name}")
+          rescue Exception => error
+            logger.error("Error stopping RPC server: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_handle
+            yield
+          rescue Exception => error
+            logger.error("Error handling request: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_reply
+            yield
+          rescue Exception => error
+            logger.error("Error replying request: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_failed(error)
+            logger.error("Error on RPC server when handling a message #{name}\n#{error.message}\n#{error.backtrace}")
+            yield
+          rescue Exception => error
+            logger.error("Error handling RPC server handler failure: #{name}\n#{error.message}\n#{error.backtrace}")
+            raise error
+          end
+
+          def on_clean
+            yield
+          rescue Exception => error
+            logger.error("Error cleaning rpc server: #{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
+end