liebre 0.1.3

data/lib/liebre/runner/starter/resources.rb

@@ -0,0 +1,39 @@
+module Liebre
+  class Runner
+    class Starter
+      class Resources
+        autoload :QueueBuilder, "liebre/runner/starter/resources/queue_builder"
+
+        def initialize connection, config
+          @connection   = connection
+          @config = config
+        end
+
+        def exchange
+          @exchange ||= queue_builder.exchange
+        end
+
+        def queue
+          @queue ||= queue_builder.queue
+        end
+
+        def channel
+          @channel ||= connection.create_channel(nil, pool_size)
+        end
+
+        private
+        
+        def queue_builder
+          @queue_bilder ||= QueueBuilder.new(channel, config)
+        end
+
+        def pool_size
+          config.fetch("pool_size", 1)
+        end
+
+        attr_reader :connection, :config
+
+      end
+    end
+  end
+end

data/lib/liebre/runner/starter/resources/queue_builder.rb

@@ -0,0 +1,58 @@
+module Liebre
+  class Runner
+    class Starter
+      class Resources
+        class QueueBuilder
+
+          def initialize channel, config
+            @channel = channel
+            @config  = config
+          end
+
+          def queue
+            q = channel.queue(queue_name, queue_opts)
+            routing_keys.each do |key|
+              q.bind(exchange, bind_opts.merge(:routing_key => key))
+            end
+            q
+          end
+
+          def exchange
+            Liebre::Common::Utils.create_exchange channel, exchange_config
+          end
+
+          private
+
+          def queue_name
+            queue_config.fetch("name")
+          end
+
+          def queue_opts
+            Liebre::Common::Utils.symbolize_keys queue_config.fetch("opts", {})
+          end
+
+          def exchange_config
+            config.fetch("exchange")
+          end
+
+          def queue_config
+            config.fetch("queue")
+          end
+          
+          def routing_keys
+            bind_opts[:routing_key] ||= queue_name
+            bind_opts[:routing_key] = [*bind_opts[:routing_key]]
+            bind_opts.delete :routing_key
+          end
+
+          def bind_opts
+            @bind_opts ||= Liebre::Common::Utils.symbolize_keys config.fetch("bind", {})
+          end
+
+          attr_reader :channel, :config
+          
+        end
+      end
+    end
+  end
+end

data/lib/liebre/runner/starter/rpc.rb

@@ -0,0 +1,45 @@
+module Liebre
+  class Runner
+    class Starter
+      class RPC < Consumer
+
+        def call
+          queue.subscribe(:manual_ack => false) do |_info, meta, payload|
+            begin
+              logger.debug "Received message for #{klass.name}: #{payload} - #{meta}"
+              consumer = klass.new(payload, meta, callback(meta))
+              consumer.call
+            rescue => e
+              logger.error e.inspect
+              logger.error e.backtrace.join("\n")
+            end
+          end
+        end
+        
+        private
+
+        def callback meta
+          opts = {
+            :routing_key    => meta.reply_to,
+            :correlation_id => meta.correlation_id,
+            :headers        => meta.headers
+          }
+
+          lambda do |response| 
+            logger.debug "Responding with #{response}"
+            exchange.publish(response, opts)
+          end
+        end
+
+        def exchange
+          channel.default_exchange
+        end
+        
+        def parse_config
+          config
+        end
+        
+      end
+    end
+  end
+end

data/lib/liebre/tasks.rb

@@ -0,0 +1,12 @@
+require 'liebre'
+
+task :environment
+
+namespace :liebre do
+  
+  desc "Starts Liebre:Runner"
+  task :run => :environment do
+    Liebre::Runner.new.start
+  end
+  
+end

data/lib/liebre/version.rb

@@ -0,0 +1,5 @@
+module Liebre
+  
+  VERSION = "0.1.3"
+
+end

data/liebre.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'liebre/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "liebre"
+  spec.version       = Liebre::VERSION
+  spec.authors       = ["jcabotc", "graimon"]
+  spec.email         = ["jcabot@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/qustodian/liebre"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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_development_dependency "bundler", '~> 1.6'
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+end

data/spec/config/liebre.yml

@@ -0,0 +1,47 @@
+rpc_request_timeout: 30
+
+consumers:
+  some_consumer:
+    class_name: MyConsumer
+    rpc: false
+    pool_size: 1
+    num_threads: 3
+    exchange:
+      name: "consumer_exchange"
+      type: "fanout"
+      opts:
+        durable: false
+    queue:
+      name: "consumer_queue"
+      opts:
+        durable: false
+        
+  some_rpc:
+    class_name: MyRPC
+    rpc: true
+    connection_name: rpc
+    pool_size: 1
+    exchange:
+      name: "rpc_exchange"
+      type: "fanout"
+      opts:
+        durable: false
+    queue:
+      name: "rpc_queue"
+      opts:
+        durable: false
+  
+publishers:
+  some_publisher:
+    exchange:
+      name: "consumer_exchange"
+      type: "fanout"
+      opts:
+        durable: false
+  rpc_publisher:
+    connection_name: rpc
+    exchange:
+      name: "rpc_exchange"
+      type: "fanout"
+      opts:
+        durable: false

data/spec/config/rabbitmq.yml

@@ -0,0 +1,35 @@
+development:
+  default:
+    :host: localhost
+    :port: 5672
+    :user: guest
+    :pass: guest
+    :vhost: /
+    :threaded: true
+    :heartbeat: 2
+  rpc:
+    :host: localhost
+    :port: 5672
+    :user: guest
+    :pass: guest
+    :vhost: /
+    :threaded: true
+    :heartbeat: 2
+
+test:
+  default:
+    :host: localhost
+    :port: 5672
+    :user: guest
+    :pass: guest
+    :vhost: /
+    :threaded: true
+    :heartbeat: 2
+  rpc:
+    :host: localhost
+    :port: 5672
+    :user: guest
+    :pass: guest
+    :vhost: /
+    :threaded: true
+    :heartbeat: 2

data/spec/integration_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+RSpec.describe "Integration" do
+  
+  class MyConsumer
+    
+    def initialize payload, meta
+      @payload = payload
+      @meta = meta
+    end
+    
+  end
+  
+  class MyRPC
+    
+    def initialize payload, meta, callback
+      @payload = payload
+      @meta = meta
+      @callback = callback
+    end
+    
+    def call
+      @callback.call(@payload)
+    end
+    
+  end
+  
+  let :config_path do
+    File.expand_path("../config/liebre.yml" ,__FILE__)
+  end
+    
+  let :connection_path do
+    File.expand_path("../config/rabbitmq.yml" ,__FILE__)
+  end
+  
+  before do
+    Liebre::Config.config_path     = config_path
+    Liebre::Config.connection_path = connection_path
+  end
+  
+  let(:consumer) { double 'consumer' }
+  
+  it do
+    
+    main_thread = Thread.new do
+      server = Liebre::Runner.new
+      server.start
+    end
+    
+    publisher = Liebre::Publisher.new("some_publisher")
+    
+    allow(MyConsumer).to receive(:new).with("hello", anything).and_return consumer
+    
+    #the consumer returns first :ack, then :reject and the message gets requed, then :error, and the message turns dead-lettered
+    expect(consumer).to receive(:call).and_return :ack, :reject, :error
+    
+    publisher.enqueue "hello", :routing_key => "consumer_queue" #:ack
+    publisher.enqueue "hello", :routing_key => "consumer_queue" #:reject then :error
+    
+    
+    
+    rpc_publisher = Liebre::Publisher.new("rpc_publisher")
+    
+    param = "return this string"
+    
+    result = rpc_publisher.rpc param, :routing_key => "rpc_queue"
+    
+    expect(result).to eq param
+    
+    sleep 0.1
+  end
+  
+end

data/spec/liebre/config_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Config do
+  
+  let :config_path do
+    File.expand_path("../../config/liebre.yml" ,__FILE__)
+  end
+    
+  let :connection_path do
+    File.expand_path("../../config/rabbitmq.yml" ,__FILE__)
+  end
+    
+  before do
+    described_class.config_path     = config_path
+    described_class.connection_path = connection_path
+    described_class.env = "some_env"
+  end
+
+  subject { described_class.new }
+
+  describe '.config_path and .connection_path and .env' do
+
+    it do
+      expect(described_class.config_path).to eq config_path
+      expect(described_class.connection_path).to eq connection_path
+      expect(described_class.env).to eq "some_env"
+    end
+  end
+  
+  describe '#consumers' do
+    
+    let(:consumer_names) { %w{ some_consumer some_rpc } }
+    
+    let(:consumer_config) do
+      {
+        'class_name' => "MyConsumer",
+        'rpc' => false
+      }
+    end
+    
+    let(:rpc_config) do
+      {
+        'class_name' => "MyRPC",
+        'rpc' => true
+      }
+    end
+    
+    it do
+      
+      expect(subject.consumers.keys).to eq consumer_names
+      
+      expect(subject.consumers['some_consumer']['class_name']).to eq consumer_config['class_name']
+      expect(subject.consumers['some_consumer']['rpc']).to eq consumer_config['rpc']
+      
+      expect(subject.consumers['some_rpc']['class_name']).to eq rpc_config['class_name']
+      expect(subject.consumers['some_rpc']['rpc']).to eq rpc_config['rpc']
+      
+    end
+    
+  end
+
+end

data/spec/liebre/connection_manager_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::ConnectionManager do
+    
+  let :connection_path do
+    File.expand_path("../../config/rabbitmq.yml" ,__FILE__)
+  end
+
+  subject { described_class.new connection_path }
+
+  describe '.start and .get' do
+
+    it do
+      subject.start
+      
+      bunny = subject.get :default
+      
+      expect(bunny.connected?).to be true
+      
+    end
+  end
+
+  describe '.restart' do
+    
+    before do
+      subject.start
+    end
+
+    it do
+      
+      subject.restart
+      
+      bunny = subject.get :rpc
+      
+      expect(bunny.connected?).to be true
+      
+    end
+  end
+  
+end