liebre 0.1.21 → 0.2.1

data/lib/liebre/bridge/channel_builder.rb

@@ -0,0 +1,36 @@
+module Liebre
+  class Bridge
+    class ChannelBuilder
+
+      DEFAULT_PREFETCH = 10
+
+      def initialize connections, opts
+        @connections = connections
+        @opts        = opts
+      end
+
+      def call
+        connection.open_channel.tap do |channel|
+          channel.set_prefetch(prefetch_count)
+        end
+      end
+
+    private
+
+      def connection
+        connections.fetch(conn_name)
+      end
+
+      def conn_name
+        opts.fetch(:connection)
+      end
+
+      def prefetch_count
+        opts.fetch(:prefetch_count, DEFAULT_PREFETCH)
+      end
+
+      attr_reader :connections, :opts
+
+    end
+  end
+end

data/lib/liebre/config.rb

@@ -1,47 +1,17 @@
-require "yaml"
-
 module Liebre
   class Config
 
-    CONFIG_PATH = File.expand_path("config/liebre.yml")
-    CONNECTION_PATH = File.expand_path("config/rabbitmq.yml")
-    DEFAULT_LOGGER = Logger.new STDOUT
-    DEFAULT_RPC_TIMEOUT = 5
-    
-    class << self
-      attr_accessor :env
-      attr_writer :config_path, :connection_path, :logger
-      
-      def config_path
-        @config_path || CONFIG_PATH
-      end
-      
-      def connection_path
-        @connection_path || CONNECTION_PATH
-      end
-      
-      def logger
-        @logger || DEFAULT_LOGGER
-      end
-      
-    end
-    
-    def consumers
-      config.fetch 'consumers', {}
-    end
-    
-    def publishers
-      config.fetch 'publishers', {}
-    end
-    
-    def rpc_request_timeout
-      config.fetch 'rpc_request_timeout', DEFAULT_RPC_TIMEOUT
+    attr_accessor :adapter, :connections, :actors
+    attr_writer :logger
+
+    def logger
+      @logger || null_logger
     end
 
-    private
+  private
 
-    def config
-      @config ||= YAML.load_file self.class.config_path
+    def null_logger
+      @null_logger ||= Logger.new(nil)
     end
 
   end

data/lib/liebre/engine.rb

@@ -0,0 +1,61 @@
+require "liebre/engine/state"
+require "liebre/engine/builder"
+
+require "liebre/engine/repository"
+
+module Liebre
+  class Engine
+
+    def initialize config
+      @config = config
+    end
+
+    def start only: nil
+      bridge.start
+
+      state.to_start(only: only) do |type, name, opts|
+        actor = build(type, name, opts)
+        actor.start
+
+        repo.insert(type, name, actor)
+      end
+    end
+
+    def clean only: nil
+      bridge.start
+
+      state.to_clean(only: only) do |type, name, opts|
+        actor = build(type, name, opts)
+        actor.clean
+      end
+    end
+
+    def stop
+      repo.each(&:stop)
+      repo.clear
+      bridge.stop
+    end
+
+    def repo
+      @repo ||= Repository.new
+    end
+
+  private
+
+    def build type, name, opts
+      builder = Builder.new(bridge, type, name, opts, config)
+      builder.call
+    end
+
+    def state
+      @state ||= State.new(config.actors)
+    end
+
+    def bridge
+      @bridge ||= Bridge.new(config)
+    end
+
+    attr_reader :config
+
+  end
+end

data/lib/liebre/engine/builder.rb

@@ -0,0 +1,48 @@
+module Liebre
+  class Engine
+    class Builder
+
+      CONTEXT = Actor::Context
+
+      ACTORS = {
+        :publishers  => Actor::Publisher,
+        :consumers   => Actor::Consumer,
+        :rpc_clients => Actor::RPC::Client,
+        :rpc_servers => Actor::RPC::Server
+      }
+
+      def initialize bridge, type, name, opts, config, context: CONTEXT, actors: ACTORS
+        @bridge = bridge
+        @type   = type
+        @name   = name
+        @opts   = opts
+        @config = config
+
+        @context_class = context
+        @actor_classes = actors
+      end
+
+      def call
+        actor_class.new(context)
+      end
+
+    private
+
+      def actor_class
+        actor_classes.fetch(type)
+      end
+
+      def context
+        context_class.new(chan, name, opts, config)
+      end
+
+      def chan
+        bridge.open_channel(opts)
+      end
+
+      attr_reader :bridge, :type, :name, :opts, :config,
+                  :context_class, :actor_classes
+
+    end
+  end
+end

data/lib/liebre/engine/repository.rb

@@ -0,0 +1,56 @@
+module Liebre
+  class Engine
+    class Repository
+
+      def initialize
+        @publishers  = {}
+        @consumers   = {}
+        @rpc_clients = {}
+        @rpc_servers = {}
+      end
+
+      def insert type, name, resource
+        case type
+          when :publishers  then publishers[name]  = resource
+          when :consumers   then consumers[name]   = resource
+          when :rpc_clients then rpc_clients[name] = resource
+          when :rpc_servers then rpc_servers[name] = resource
+        end
+      end
+
+      def all
+        publishers.values + consumers.values + rpc_clients.values + rpc_servers.values
+      end
+
+      def each &block
+        all.each(&block)
+      end
+
+      def clear
+        publishers.clear
+        consumers.clear
+        rpc_clients.clear
+        rpc_servers.clear
+      end
+
+      def publisher name
+        publishers.fetch(name)
+      end
+
+      def consumer name
+        consumers.fetch(name)
+      end
+
+      def rpc_client name
+        rpc_clients.fetch(name)
+      end
+
+      def rpc_server name
+        rpc_servers.fetch(name)
+      end
+
+      attr_reader :publishers, :consumers, :rpc_clients, :rpc_servers
+
+    end
+  end
+end

data/lib/liebre/engine/state.rb

@@ -0,0 +1,49 @@
+module Liebre
+  class Engine
+    class State
+
+      def initialize config
+        @config  = config
+        @started = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def to_start only: nil
+        all do |type, name, opts|
+          if has_to_start?(type, name, only)
+            yield(type, name, opts)
+            set_started(type, name)
+          end
+        end
+      end
+
+      def to_clean only: nil
+        all do |type, name, opts|
+          yield(type, name, opts) if match?(type, only)
+        end
+      end
+
+    private
+
+      def has_to_start? type, name, only
+        started[type][name].nil? and match?(type, only)
+      end
+
+      def match? type, only
+        only.nil? or only.include?(type)
+      end
+
+      def set_started type, name
+        started[type][name] = true
+      end
+
+      def all
+        config.each do |type, specs|
+          specs.each { |name, opts| yield(type, name, opts) }
+        end
+      end
+
+      attr_reader :config, :started
+
+    end
+  end
+end

data/lib/liebre/runner.rb

@@ -1,65 +1,33 @@
 module Liebre
   class Runner
-    
-    autoload :Consumers, 'liebre/runner/consumers'
-    autoload :Starter,   'liebre/runner/starter'
-    
+
     RETRY_INTERVAL = 5
 
-    def initialize retry_interval = RETRY_INTERVAL
-      @retry_interval = retry_interval
+    def initialize engine: Liebre.engine
+      @engine = engine
     end
 
-    def start
-      setup_shutdown
-      connection_manager.restart
-      start_consumers
+    def run only: nil
+      setup_signals
+      engine.start(only: only)
       sleep
-    rescue StandardError => e
-      log_and_wait(e)
+    rescue => e
+      sleep(RETRY_INTERVAL)
       retry
     end
 
-    private
-
-    def setup_shutdown
-      Signal.trap("TERM") { do_shutdown; exit }
-      Signal.trap("USR1") { do_shutdown; exit }
-    end
-
-    def do_shutdown
-      Thread.start do
-        logger.info("Liebre# Closing AMQP connection...")
-        consumers.stop
-        connection_manager.stop
-        logger.info("Liebre# AMQP connection closed")
-      end.join
-    end
-
-    def start_consumers
-      logger.info("Liebre# Starting consumers...")
-      consumers.start_all
-    end
+  private
 
-    def log_and_wait e
-      logger.warn(e)
-      sleep(retry_interval)
-      logger.warn("Liebre# Retrying connection")
-    end
-
-    def logger
-      Liebre.logger
-    end
-    
-    def consumers
-      @consumers ||= Consumers.new(connection_manager)
+    def setup_signals
+      Signal.trap("TERM") { do_stop; exit }
+      Signal.trap("USR1") { do_stop; exit }
     end
 
-    def connection_manager
-      @connection_manager ||= ConnectionManager.instance
+    def do_stop
+      Thread.new { engine.stop }.join
     end
 
-    attr_reader :retry_interval
+    attr_reader :engine
 
   end
 end

data/lib/liebre/version.rb

@@ -1,5 +1,5 @@
 module Liebre
 
-  VERSION = "0.1.21"
+  VERSION = "0.2.1"
 
 end

data/liebre.gemspec

@@ -6,10 +6,10 @@ require 'liebre/version'
 Gem::Specification.new do |spec|
   spec.name          = "liebre"
   spec.version       = Liebre::VERSION
-  spec.authors       = ["jcabotc", "graimon"]
-  spec.email         = ["jcabot@gmail.com", "graimon@gmail.com"]
-  spec.summary       = %q{A gem to consume and publish to RabbitMQ based on Bunny, creates a thread for every consumer}
-  spec.homepage      = "https://github.com/iadbox/liebre"
+  spec.authors       = ["jcabotc"]
+  spec.email         = ["jcabot@gmail.com"]
+  spec.summary       = %q{Some abstractions to interact with a AMQP broker}
+  spec.homepage      = ""
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -17,10 +17,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "bunny", '~> 2.5', '>= 2.5.1'
+  spec.add_dependency "concurrent-ruby"
 
-  spec.add_development_dependency "bundler", '~> 1.6'
+  spec.add_development_dependency "bunny"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake"
 end

data/spec/integration/publish_and_consume_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe "Publish and consume" do
+
+  let(:connections) { {"test_conn" => {}} }
+
+  let :exchange do
+    {:name => "__test__.liebre.publish_and_consume_exchange",
+     :type => "fanout",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let :queue do
+    {:name => "__test__.liebre.publish_and_consume_queue",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let(:handler_class) { double 'handler_class' }
+  let(:handler)       { double 'handler' }
+
+  let :actors do
+    {
+      :publishers => {
+        :my_publisher => {
+          :connection => "test_conn",
+          :resources  => {:exchange => exchange}
+        }
+      },
+      :consumers => {
+        :my_consumer => {
+          :connection     => "test_conn",
+          :prefetch_count => 5,
+          :pool_size      => 1,
+          :handler        => handler_class,
+          :resources      => {:exchange => exchange, :queue => queue}
+        }
+      }
+    }
+  end
+
+  let :config do
+    Liebre::Config.new.tap do |config|
+      config.adapter     = Liebre::Adapter::Bunny
+      config.connections = connections
+      config.actors      = actors
+    end
+  end
+
+  let(:payload) { "some_data" }
+  let(:headers) { {"foo" => "bar"} }
+
+  it "sends and receives data" do
+    engine = Liebre::Engine.new(config)
+    engine.start
+
+    repo      = engine.repo
+    publisher = repo.publisher(:my_publisher)
+
+    expect(handler_class).to receive :new do |payload, meta, callback|
+      expect(payload     ).to eq payload
+      expect(meta.headers).to eq headers
+
+      handler
+    end
+    expect(handler).to receive(:call)
+
+    sleep(0.1) # wait for the consumer to bind its queue to the exchange
+    publisher.publish(payload, :headers => headers)
+
+    sleep(0.2) # wait for the message to be published and consumed
+  end
+
+end