liebre 0.1.21 → 0.2.1

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

@@ -1,59 +0,0 @@
-module Liebre
-  class Runner
-    class Starter
-      class RPC < Consumer
-
-        def start
-          @consumer = queue.subscribe(:manual_ack => false) do |_info, meta, payload|
-            begin
-              debug_string = "Liebre# Received message for #{klass.name}(#{queue.name}): #{payload} - #{meta}"
-              start_at = Time.now
-              call_consumer payload, meta
-              elapsed_time = (Time.now - start_at).to_f * 1000
-              log_result debug_string, elapsed_time
-            rescue StandardError => e
-              response = :error
-              logger.error error_string(payload, meta)
-            rescue Exception => e
-              response = :error
-              logger.error error_string(payload, meta)
-              handler.respond response, info
-              raise e
-            end
-          end
-        end
-        
-        protected
-        
-        def call_consumer payload, meta
-          consumer = klass.new(payload, meta, callback(meta))
-          consumer.call
-        end
-        
-        private
-
-        def callback meta
-          opts = {
-            :routing_key    => meta.reply_to,
-            :correlation_id => meta.correlation_id,
-            :headers        => meta.headers
-          }
-
-          lambda do |response| 
-            logger.debug "Liebre# 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

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

data/spec/config/liebre.yml

@@ -1,48 +0,0 @@
-rpc_request_timeout: 30
-
-consumers:
-  some_consumer:
-    class_name: MyConsumer
-    rpc: false
-    pool_size: 1
-    num_threads: 3
-    prefetch_count: 5
-    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

@@ -1,35 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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::ConnectionManager.instance_variable_set :@singleton__instance__, nil
-    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
-
-    sleep 0.1
-
-    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

@@ -1,63 +0,0 @@
-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_consumer']['prefetch_count']).to eq 5
-
-      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

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Liebre::ConnectionManager do
-    
-  let :connection_path do
-    File.expand_path("../../config/rabbitmq.yml" ,__FILE__)
-  end
-  
-  before do
-    Liebre::Config.connection_path = connection_path
-  end
-
-  subject { described_class.instance }
-
-  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

data/spec/liebre/publisher_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Liebre::Publisher do
-
-  let :exchange_config do
-    { 
-      'name' => "test_exchange",
-      'type' => "direct",
-      'opts' => {
-        'durable' => false
-      }
-    }
-  end
-  
-  let :publishers_config do
-    { 
-      'test_publisher' => {
-        'exchange' =>
-          exchange_config 
-      }
-    }
-  end
-  
-  let(:channel)            { double 'channel' }
-  let(:connection_manager) { double 'connection_manager' }
-  let(:exchange)           { double 'exchange', :name => "exchange" }
-  
-  before do
-    allow_any_instance_of(Liebre::Config).to receive(:publishers).and_return publishers_config
-    allow_any_instance_of(Liebre::Config).to receive(:rpc_request_timeout).and_return 10
-    
-    allow(Liebre::ConnectionManager).to receive(:instance).and_return connection_manager
-    expect(connection_manager).to receive(:ensure_started)
-    
-    expect(Liebre::Common::Utils).to receive(:create_exchange).
-      with(channel, exchange_config).and_return exchange
-    
-  end
-  
-  subject { described_class.new 'test_publisher' }
-  
-  describe "#enqueue" do
-    before do
-      expect(connection_manager).to receive(:channel_for).with(:default).and_return channel
-    end
-    
-    it do
-      message = "abc"
-      expect(exchange).to receive(:publish).with message, {}
-    
-      subject.enqueue message
-    end
-  end
-  
-  describe "#enqueue_and_wait" do
-    
-    let(:correlation_id)   { "correlation_id" }
-    let(:reply_queue_name) { "test_publisher_callback_#{correlation_id}" }
-    let(:reply_queue)      { double "reply_queue", :name => reply_queue_name }
-    let(:delivery_info)    { double "delivery_info", :consumer_tag => "tag"}
-    let(:consumer)         { double 'consumer' }
-    let(:connection)       { double 'connection' }
-    let(:consumers)        { {"tag" => consumer} }
-    
-    before do
-      expect(connection_manager).to receive(:get).with(:default).and_return connection
-      expect(connection).to receive(:create_channel).and_return channel
-      expect(channel).to receive(:prefetch).with 1
-      expect(channel).to receive(:queue).with(reply_queue_name, :exclusive => true, :auto_delete => true).
-        and_return reply_queue
-      expect(channel).to receive(:close)
-    end
-    
-    it do
-      message = "question"
-      answer = "answer"
-      expect(exchange).to receive(:publish).with message, 
-        {:correlation_id => correlation_id, :reply_to => reply_queue_name}
-      
-      expect(reply_queue).to receive(:subscribe).with(:block => false) do |&block|
-        expect(channel).to receive(:consumers).and_return consumers
-        expect(consumer).to receive(:cancel)
-        
-        block.call(delivery_info, {:correlation_id => correlation_id}, answer)
-      end
-    
-      result = subject.enqueue_and_wait message, :correlation_id => correlation_id
-      expect(result).to eq answer
-    end
-  end
-  
-end

data/spec/liebre/runner/consumers_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Liebre::Runner::Consumers do
-
-  let(:conn) { double 'conn' }
-
-  let(:first_expected_config)  do 
-    {
-      "class_name" => "MyConsumer",
-      "num_threads" => 3,
-      "rpc" => false
-    } 
-  end
-    
-  let(:second_expected_config) do 
-    {
-      "class_name" => "MyRPC",
-      "rpc" => true
-    }
-  end
-  
-  let(:consumers_config) do 
-    {
-      "some_consumer" => first_expected_config,
-      "some_rpc" => second_expected_config
-    }
-  end
-    
-  before do
-    allow(subject).to receive(:consumers).and_return consumers_config
-  end
-
-  subject { described_class.new(conn) }
-
-  describe "#consumer_names" do
-    it "returns all names" do
-      expect(subject.consumer_names).to eq ["some_consumer", "some_rpc"]
-    end
-  end
-
-  describe "#start_all" do
-    let(:first_starter)  { double 'first_starter' }
-    let(:second_starter) { double 'second_starter' }
-
-    it "starts the given consumers" do
-      expect(Liebre::Runner::Starter).to receive(:new).exactly(3).times.
-        with(conn, first_expected_config).and_return(first_starter)
-
-      expect(Liebre::Runner::Starter).to receive(:new).
-        with(conn, second_expected_config).and_return(second_starter)
-
-      expect(first_starter ).to receive(:start).exactly(3).times
-      expect(second_starter).to receive(:start)
-
-      subject.start_all
-    end
-  end
-
-end