batsir 0.1.0 → 0.3.7

data/lib/batsir/strategies/strategy.rb

@@ -0,0 +1,20 @@
+module Batsir
+  module Strategies
+    class Strategy
+
+      attr_reader :context
+
+      def initialize(context)
+        if context.respond_to? :execute
+          @context = context
+        else
+          raise Batsir::Errors::ExecuteMethodNotImplementedError.new
+        end
+      end
+
+      def execute(message, error = nil)
+      end
+
+    end
+  end
+end

data/lib/batsir/transformers/field_transformer.rb

@@ -14,7 +14,7 @@ module Batsir
         end
       end
 
-      def transform(message)
+      def execute(message)
         fields = self.fields
         if fields.any? && message.respond_to?(:keys)
           symbolized_message_keys = {}
@@ -25,7 +25,7 @@ module Batsir
           fields_to_remove = symbolized_message_keys.keys - fields.keys - fields.values
 
           fields.each do |new, old|
-            message[new] = message.delete(symbolized_message_keys[old])
+            message[new.to_s] = message.delete(symbolized_message_keys[old])
           end
 
           fields_to_remove.each do |field|
@@ -34,7 +34,6 @@ module Batsir
         end
         message
       end
-
     end
   end
 end

data/lib/batsir/transformers/json_input_transformer.rb

@@ -1,8 +1,12 @@
 module Batsir
   module Transformers
     class JSONInputTransformer < Transformer
-      def transform(message)
-        JSON.parse(message, :symbolize_names => false)
+      def execute(message)
+        begin
+          JSON.parse(message, :symbolize_names => false)
+        rescue JSON::JSONError => e
+          raise Batsir::Errors::JSONInputTransformError.new(e.message)
+        end
       end
     end
   end

data/lib/batsir/transformers/json_output_transformer.rb

@@ -1,8 +1,12 @@
 module Batsir
   module Transformers
     class JSONOutputTransformer < Transformer
-      def transform(message)
-        JSON.dump(message)
+      def execute(message)
+        begin
+          JSON.dump(message)
+        rescue JSON::JSONError => e
+          raise Batsir::Errors::JSONOutputTransformError.new(e.message)
+        end
       end
     end
   end

data/lib/batsir/transformers/transformer.rb

@@ -8,7 +8,11 @@ module Batsir
       end
 
       def transform(message)
-        message
+        execute(message)
+      end
+
+      def execute(message)
+        raise NotImplementedError.new
       end
     end
   end

data/lib/batsir/version.rb

@@ -0,0 +1,10 @@
+module Batsir
+  module Version
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 7
+    BUILD = nil
+  end
+
+  VERSION = [Version::MAJOR, Version::MINOR, Version::PATCH, Version::BUILD].compact.join('.')
+end

data/lib/batsir.rb

@@ -1,42 +1,48 @@
 require 'blockenspiel'
 require 'celluloid'
 require 'json'
+require 'log4r'
 require 'bunny'
 require 'sidekiq'
 require 'sidekiq/cli'
-require 'batsir/registry'
+require 'batsir/amqp_consumer'
 require 'batsir/config'
 require 'batsir/chain'
+require 'batsir/errors'
 require 'batsir/filter'
 require 'batsir/filter_queue'
+require 'batsir/log'
+require 'batsir/logger'
+require 'batsir/logo'
+require 'batsir/registry'
 require 'batsir/stage'
 require 'batsir/stage_worker'
+require 'batsir/compiler/stage_worker_compiler'
 require 'batsir/dsl/dsl_mappings'
+require 'batsir/dsl/conditional_notifier_declaration'
 require 'batsir/acceptors/acceptor'
 require 'batsir/acceptors/amqp_acceptor'
 require 'batsir/notifiers/notifier'
 require 'batsir/notifiers/amqp_notifier'
+require 'batsir/notifiers/conditional_notifier'
 require 'batsir/transformers/transformer'
 require 'batsir/transformers/field_transformer'
 require 'batsir/transformers/json_input_transformer'
 require 'batsir/transformers/json_output_transformer'
-require 'batsir/logo'
+require 'batsir/strategies/strategy'
+require 'batsir/strategies/retry_strategy'
+require 'batsir/version'
 
 module Batsir
-  def self.config
-    @config ||= Batsir::Config.new(config_defaults)
-  end
 
-  def self.config_defaults
-    {
-      :redis_url => "redis://localhost:6379/0"
-    }
+  def self.config
+    Batsir::Config
   end
 
   def self.create(&block)
     puts logo
     new_block = ::Proc.new do
-      aggregator_chain &block
+      aggregator_chain(&block)
     end
     @chain = ::Blockenspiel.invoke(new_block, Batsir::DSL::ChainMapping.new)
   end
@@ -45,7 +51,7 @@ module Batsir
     return unless @chain
 
     sidekiq_cli = Sidekiq::CLI.instance
-    Sidekiq.options[:queues] << 'default'
+    Sidekiq.options[:queues] << Batsir::Config.sidekiq_queue
 
     initialize_sidekiq
 
@@ -58,11 +64,12 @@ module Batsir
   end
 
   def self.initialize_sidekiq
+    Sidekiq.logger = Batsir::Logger.log
     Sidekiq.configure_server do |config|
-      config.redis = {:url => Batsir.config.redis_url}
+      config.redis = {:url => redis_url, :namespace => redis_namespace}
     end
     Sidekiq.configure_client do |config|
-      config.redis = {:url => Batsir.config.redis_url}
+      config.redis = {:url => redis_url, :namespace => redis_namespace}
     end
   end
 
@@ -70,4 +77,15 @@ module Batsir
     create(&block)
     start
   end
+
+  def self.redis_url
+    host = Batsir::Config.redis_host
+    port = Batsir::Config.redis_port
+    dbase = Batsir::Config.redis_database
+    "redis://#{host}:#{port}/#{dbase}"
+  end
+
+  def self.redis_namespace
+    Batsir::Config.redis_namespace
+  end
 end

data/spec/batsir/acceptors/acceptor_spec.rb

@@ -1,89 +1,19 @@
 require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+require File.join( File.dirname(__FILE__), 'shared_examples')
+
 
 describe Batsir::Acceptors::Acceptor do
+  it_behaves_like "an acceptor", Batsir::Acceptors::Acceptor
+
   let( :acceptor_class ) {
     Batsir::Acceptors::Acceptor
   }
 
-  it "should be a Celluloid actor" do
+  it "is a Celluloid actor" do
     acceptor_class.ancestors.should include Celluloid
   end
 
-  it "should be possible to set the stage name for the acceptor" do
-    acceptor = acceptor_class.new
-    stage_name = "some stage"
-    acceptor.stage_name = stage_name
-    acceptor.stage_name.should == stage_name
-  end
-
-  it "should have a #start method" do
-    acceptor_class.instance_methods.map{|im| im.to_s}.should include "start"
-  end
-
-  it "should have an #start_filter_chain method" do
-    acceptor_class.instance_methods.map{|im| im.to_s}.should include "start_filter_chain"
-  end
-
-  it "should be possible to initialize an Acceptor with on options hash" do
-    acceptor = acceptor_class.new({})
-    acceptor.should_not be_nil
-  end
-
-  it "should look up a worker class when the #start_filter_chain method is called" do
-    acceptor = acceptor_class.new
-    stage_name = "some stage"
-    acceptor.stage_name = stage_name
-    Batsir::Registry.should_receive(:get).with(stage_name)
-    acceptor.start_filter_chain({})
-  end
-
-  it "should have a transformer_queue" do
-    acceptor = acceptor_class.new
-    acceptor.transformer_queue.should_not be_nil
-  end
-
-  it "should initially have an empty transformer_queue" do
-    acceptor = acceptor_class.new
-    acceptor.transformer_queue.should_not be_nil
-    acceptor.transformer_queue.should be_empty
-  end
-
-  it "should be possible to add a transformer to the transformer_queue" do
-    transformer = :transformer
-
-    acceptor = acceptor_class.new
-    acceptor.add_transformer transformer
-
-    acceptor.transformer_queue.should_not be_empty
-    acceptor.transformer_queue.size.should == 1
-    acceptor.transformer_queue.first.should == :transformer
-  end
-
-  it "should be possible to add a transformer multiple times" do
-    transformer = :transformer
-
-    acceptor = acceptor_class.new
-    acceptor.add_transformer transformer
-    acceptor.add_transformer transformer
-
-    acceptor.transformer_queue.should_not be_empty
-    acceptor.transformer_queue.size.should == 2
-  end
-
-  it "should be possible to set a cancellator" do
-    cancellator = :cancel
-    acceptor = acceptor_class.new
-    acceptor.cancellator = cancellator
-    acceptor.cancellator.should == cancellator
-  end
-
-  it "should be possible to set a cancellator in the constructor using a hash" do
-    cancellator = :cancel
-    acceptor = acceptor_class.new(:cancellator => cancellator)
-    acceptor.cancellator.should == cancellator
-  end
-
-  it "should call the #perform_async on the worker class when #start_filter_chain is called" do
+  it "calls the #perform_async on the worker class when #start_filter_chain is called" do
     class MockWorker
       def self.stage_name
         "mock_stage"
@@ -108,7 +38,7 @@ describe Batsir::Acceptors::Acceptor do
     acceptor.start_filter_chain({})
   end
 
-  it "should call #transform on the acceptor transformers" do
+  it "calls #transform on the acceptor transformers" do
     class MockTransformer < Batsir::Transformers::Transformer
       def transform(message)
         @@transformed ||= 0
@@ -123,7 +53,6 @@ describe Batsir::Acceptors::Acceptor do
 
     acceptor = acceptor_class.new
     stage_name = "some stage"
-
     acceptor.stage_name = stage_name
     acceptor.add_transformer MockTransformer.new
 

data/spec/batsir/acceptors/amqp_acceptor_spec.rb

@@ -1,53 +1,69 @@
 require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+require File.join( File.dirname(__FILE__), 'shared_examples')
 
 describe Batsir::Acceptors::AMQPAcceptor do
+  it_behaves_like "an acceptor", Batsir::Acceptors::AMQPAcceptor
 
   let(:acceptor_class){
     Batsir::Acceptors::AMQPAcceptor
   }
 
-  context "With respect to setting options" do
+  context "instantiating" do
+    it "sets a bunny pool" do
+      acceptor = acceptor_class.new
+      acceptor.bunny_pool.should be_kind_of ConnectionPool
+    end
 
-    it "should be a Batsir::Acceptors::Acceptor" do
-      acceptor_class.ancestors.should include Batsir::Acceptors::Acceptor
+    it "uses the same ConnectionPool instance for each acceptor" do
+      acceptor1 = acceptor_class.new
+      acceptor2 = acceptor_class.new
+      acceptor1.should_not eql acceptor2
+      acceptor1.bunny_pool.should eql acceptor2.bunny_pool
     end
+  end
 
-    it "should be possible to set the queue on which to listen" do
+  context "setting options" do
+    it "can set the queue on which to listen" do
       acceptor = acceptor_class.new(:queue => :queue)
       acceptor.queue.should == :queue
     end
 
-    it "should be possible to set the host of the amqp broker" do
+    it "can set the host of the amqp broker" do
       acceptor = acceptor_class.new(:host => 'localhost')
       acceptor.host.should == 'localhost'
     end
 
-    it "should be possible to set the port of the amqp broker" do
+    it "can set the port of the amqp broker" do
       acceptor = acceptor_class.new(:port => 1234)
       acceptor.port.should == 1234
     end
 
-    it "should be possible to set the username with which to connect to the broker" do
+    it "can set the username with which to connect to the broker" do
       acceptor = acceptor_class.new(:username => 'some_user')
       acceptor.username.should == 'some_user'
     end
 
-    it "should be possible to set the password with which to connect to the broker" do
+    it "can set the password with which to connect to the broker" do
       acceptor = acceptor_class.new(:password => 'password')
       acceptor.password.should == 'password'
     end
 
-    it "should be possible to set the vhost to use on the broker" do
+    it "can set the vhost to use on the broker" do
       acceptor = acceptor_class.new(:vhost => '/vhost')
       acceptor.vhost.should == '/vhost'
     end
 
-    it "should be possible to set the exchange to use on the broker" do
+    it "can set the exchange to use on the broker" do
       acceptor = acceptor_class.new(:exchange => 'amq.direct')
       acceptor.exchange.should == 'amq.direct'
     end
 
-    it "should default to amqp://guest:guest@localhost:5672/ with direct exchange on vhost ''" do
+    it "can set the queue to be durable" do
+      acceptor = acceptor_class.new(:durable => true)
+      acceptor.durable.should == true
+    end
+
+    it "defaults to amqp://guest:guest@localhost:5672/ with direct exchange on vhost ''" do
       acceptor = acceptor_class.new(:queue => :somequeue)
       acceptor.queue.should    == :somequeue
       acceptor.host.should     == 'localhost'
@@ -59,79 +75,58 @@ describe Batsir::Acceptors::AMQPAcceptor do
     end
   end
 
-  context "with respect to starting the acceptor" do
+  context "starting the acceptor" do
     def new_acceptor(options = {})
-      acceptor_class.new(options)
+      acceptor_class.new({:queue => 'test_queue'}.merge options)
     end
 
-    it "should connect to the configured host" do
-      acceptor = new_acceptor(:host => 'somehost')
-      acceptor.start
-      instance = Bunny.instance
-      instance.options[:host].should == 'somehost'
+    it "starts listening on the configured queue" do
+      acceptor = new_acceptor()
+      acceptor.bunny_pool do |bunny|
+        acceptor.consumer.queue.name.should == 'test_queue'
+      end
     end
 
-    it "should connect to the configured port" do
-      acceptor = new_acceptor(:port => 1234)
+    it "connects to the configured host" do
+      acceptor = new_acceptor(:host => 'localhost')
       acceptor.start
-      instance = Bunny.instance
-      instance.options[:port].should == 1234
+      acceptor.consumer.queue.channel.connection.host.should == 'localhost'
     end
 
-    it "should connect with the configured username" do
-      acceptor = new_acceptor(:username => 'user')
+    it "connects to the configured port" do
+      acceptor = new_acceptor(:port => 5672)
       acceptor.start
-      instance = Bunny.instance
-      instance.options[:user].should == 'user'
+      acceptor.consumer.queue.channel.connection.port.should == 5672
     end
 
-    it "should connect with the configured password" do
-      acceptor = new_acceptor(:password => 'pass')
+    it "connects with the configured username" do
+      acceptor = new_acceptor(:username => 'guest', :password => 'guest')
       acceptor.start
-      instance = Bunny.instance
-      instance.options[:pass].should == 'pass'
+      acceptor.consumer.queue.channel.connection.user.should == 'guest'
+      acceptor.consumer.queue.channel.connection.pass.should == 'guest'
     end
 
-    it "should connect to the configured vhost" do
-      acceptor = new_acceptor(:vhost => '/vhost')
+    it "connects to the configured vhost" do
+      acceptor = new_acceptor(:vhost => '/')
       acceptor.start
-      instance = Bunny.instance
-      instance.options[:vhost].should == '/vhost'
+      acceptor.consumer.queue.channel.connection.vhost.should == '/'
     end
 
-    it "should declare the configured exchange" do
+    it "declares the configured exchange" do
       acceptor = new_acceptor(:exchange => 'some_exchange')
       acceptor.start
-      instance = Bunny.instance
-      instance.exchange.name.should == 'some_exchange'
+      acceptor.consumer.queue.instance_variable_get(:@bindings).first[:exchange].should == 'some_exchange'
     end
 
-    it "should bind the configured exchange to the queue" do
+    it "binds the configured exchange to the queue" do
       acceptor = new_acceptor(:exchange => 'some_exchange', :queue => :queue)
       acceptor.start
-      instance = Bunny.instance
-      queue = instance.queues[:queue]
-      queue.bound_exchange.name.should == 'some_exchange'
-      queue.bound_key.should == :queue
+      binding = acceptor.consumer.queue.instance_variable_get(:@bindings).first
+      binding[:exchange].should == 'some_exchange'
+      binding[:routing_key].should == :queue
     end
 
-    it "should start listening on the configured queue" do
-      acceptor = new_acceptor(:queue => :some_queue)
-      acceptor.start
-      instance = Bunny.instance
-      instance.queues.size.should == 1
-      instance.queues.keys.should include :some_queue
-    end
-
-    it "should initialize the subscription with the acceptor's cancellator" do
-      cancellator = :cancellator
-      acceptor = new_acceptor(:queue => :some_queue, :cancellator => cancellator)
-      acceptor.start
-      instance = Bunny.instance
-      puts instance.queues[:some_queue].arguments.first[:cancellator].should == cancellator
-    end
-
-    it "should call the #start_filter_chain method when a message is received" do
+    it "calls the #start_filter_chain method when a message is received" do
       acceptor = new_acceptor(:queue => :some_queue)
 
       # Because acceptor is a Celluloid Actor, it is not possible to define a method
@@ -155,13 +150,7 @@ describe Batsir::Acceptors::AMQPAcceptor do
       acceptor._send_(:define_singleton_method, :method_called, method_called_mock_method)
 
       acceptor.start
-
-      instance = Bunny.instance
-      queue = instance.queues[:some_queue]
-      queue.should_not be_nil
-
-      block = queue.block
-      block.call({})
+      acceptor.consumer.call({})
 
       acceptor.method_called.should == 1
     end

data/spec/batsir/acceptors/shared_examples.rb

@@ -0,0 +1,102 @@
+shared_examples_for "an acceptor" do |acceptor_class|
+  before :each do
+    subject{acceptor_class.new}
+  end
+
+  context 'properties' do
+    it "is a Batsir::Acceptors::Acceptor" do
+      subject.should be_kind_of Batsir::Acceptors::Acceptor
+    end
+
+    it "has a #start method" do
+      subject.class.instance_methods.map{|im| im.to_s}.should include "start"
+    end
+
+    it "has a #start_filter_chain method" do
+      subject.class.instance_methods.map{|im| im.to_s}.should include "start_filter_chain"
+    end
+
+    it "has a transformer_queue" do
+      subject.transformer_queue.should_not be_nil
+    end
+  end
+
+  context 'instances' do
+    it "can initialize an Acceptor with on options hash" do
+      acceptor = acceptor_class.new({})
+      acceptor.should_not be_nil
+    end
+
+    it "initially has an empty transformer_queue" do
+      subject.transformer_queue.should_not be_nil
+      subject.transformer_queue.should be_empty
+    end
+
+    it "can set the stage name for the acceptor" do
+      acceptor = acceptor_class.new
+      stage_name = "some stage"
+      acceptor.stage_name = stage_name
+      acceptor.stage_name.should == stage_name
+    end
+
+    it "looks up a worker class when the #start_filter_chain method is called" do
+      acceptor = acceptor_class.new
+      stage_name = "some stage"
+      acceptor.stage_name = stage_name
+      Batsir::Registry.should_receive(:get).with(stage_name)
+      acceptor.start_filter_chain({})
+    end
+  end
+
+  context 'transformers' do
+    it "can add a transformer to the transformer_queue" do
+      transformer = :transformer
+
+      acceptor = acceptor_class.new
+      acceptor.add_transformer transformer
+
+      acceptor.transformer_queue.should_not be_empty
+      acceptor.transformer_queue.size.should == 1
+      acceptor.transformer_queue.first.should == :transformer
+    end
+
+    it "can add a transformer multiple times" do
+      transformer = :transformer
+
+      acceptor = acceptor_class.new
+      acceptor.add_transformer transformer
+      acceptor.add_transformer transformer
+
+      acceptor.transformer_queue.should_not be_empty
+      acceptor.transformer_queue.size.should == 2
+    end
+
+    it "handles errors thrown by transformers" do
+      class ErrorAcceptor < Batsir::Acceptors::Acceptor
+        attr_accessor :message
+        def process_message_error(message, error)
+          message = "error"
+          @message = message
+        end
+      end
+
+      class MockTransformer < Batsir::Transformers::Transformer
+        def transform(message)
+          raise Batsir::Errors::TransformError.new
+        end
+      end
+
+      acceptor = ErrorAcceptor.new
+      stage_name = "some stage"
+      acceptor.stage_name = stage_name
+      acceptor.add_transformer MockTransformer.new
+
+      acceptor.message.should be_nil
+
+      acceptor.start_filter_chain({})
+
+      acceptor.message.should == "error"
+    end
+  end
+
+end

data/spec/batsir/amqp_spec.rb

@@ -0,0 +1,58 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::AMQP do
+  before :all do
+    class AMQPTest
+      include Batsir::AMQP
+    end
+    @test = AMQPTest.new
+  end
+
+  context 'with respect to default variables' do
+    it 'has a host' do
+      @test.host.should == 'localhost'
+    end
+
+    it 'has a port' do
+      @test.port.should == 5672
+    end
+
+    it 'has a username' do
+      @test.username.should == 'guest'
+    end
+
+    it 'has a password' do
+      @test.password.should == 'guest'
+    end
+
+    it 'has a vhost' do
+      @test.vhost.should == '/'
+    end
+
+    it 'has a exchange' do
+      @test.exchange.should == 'amq.direct'
+    end
+
+    it 'is durable' do
+      @test.durable.should == true
+    end
+
+    it 'is undead' do
+      @test.heartbeat.should == 0
+    end
+  end
+
+  context 'with respect to setting variables' do
+    it 'can change host' do
+      localhost = '127.0.0.1'
+      @test.host = localhost
+      @test.host.should == localhost
+    end
+
+    it 'can change heartbeat' do
+      hb = 512
+      @test.heartbeat = hb
+      @test.heartbeat.should == hb
+    end
+  end
+end