batsir 0.1.0 → 0.3.7

data/.travis.yml

@@ -4,7 +4,15 @@ jdk:
   - oraclejdk7
 
 rvm:
-  - 1.9.2
   - 1.9.3
+  - 2.0.0
   - jruby-19mode
   - rbx-19mode
+  - ruby-head
+  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode
+    - rvm: ruby-head
+    - rvm: jruby-head

data/CHANGES.md

@@ -0,0 +1,54 @@
+0.3.7
+-----------
+- AMQP queues are now durable by default.
+  This prevents queued messages getting lost when batsir is restarted (and the last consumer disconnects). It can be configured by setting 'Batsir::Config.amqp_durable'.
+- Now requires bunny 0.10.7
+
+
+0.3.6
+-----------
+- Fixes bug in conditional notifier
+- Constrained Celluloid version to 0.14.x, until we can support 0.15.x and above
+
+
+0.3.5
+-----------
+- NOTICE: This version removes sidekiq/celluloid gem contraints. Be sure to set these accordingly in your own project's Gemfile!
+
+
+0.3.4
+-----------
+- Fixed issue when using bunny 0.9.0.pre9. Bunny::Session#start now returns ifself instead of its channel.
+
+
+0.3.3
+-----------
+- Bunny :heartbeat option is now explicitly set. It defaults to 0; the original AMQP 0.8 setting.
+
+
+0.3.2
+-----------
+- Filters can now be passed initialisation options
+
+
+0.3.1
+-----------
+- Renamed config variable 'connection_pool_size' to a more apt 'amqp_pool_size'
+
+
+0.3.0
+-----------
+- AMQPAcceptor and AMQPNotifier classes now only support Bunny 0.9 and up.
+  This fixes a bug that occurred when talking to an AMQP 0.9 server with a Bunny 0.8 client.
+  High message rates would, at some point, cause the server to reject all messages.
+
+
+0.2.1
+-----------
+- Notifiers will not modify the message
+- FieldTransformers now always return message hashes with strings for keys
+
+
+0.2.0
+-----------
+- first production-ready code

data/Gemfile

@@ -1,17 +1,14 @@
-source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
+source "https://rubygems.org"
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
 gem "bundler", "> 1.0.0"
 gem "jeweler"
-gem "blockenspiel", "~> 0.4.3"
-gem "celluloid"
-gem "sidekiq"
-gem "bunny", :git => "https://github.com/ruby-amqp/bunny.git"
+gem "rdoc"
+gem "blockenspiel", ">= 0.4.3"
+gem "celluloid", "~> 0.14.1"
+gem "sidekiq", ">= 2.5.4"
+gem "bunny", :github => "ruby-amqp/bunny", :tag => "0.10.7"
 gem "json"
+gem "log4r"
 #gem "hot_bunnies", :git => "https://github.com/ruby-amqp/hot_bunnies.git"
 
 group :development do

data/README.md

@@ -1,6 +1,7 @@
+[![Gem Version](https://badge.fury.io/rb/batsir.png)](http://badge.fury.io/rb/batsir)
+[![Code Climate](https://codeclimate.com/github/jwkoelewijn/batsir.png)](https://codeclimate.com/github/jwkoelewijn/batsir)
 [![Build Status](https://secure.travis-ci.org/jwkoelewijn/batsir.png?branch=master)](http://travis-ci.org/jwkoelewijn/batsir)
 
-
 ![Batsir Logo](/jwkoelewijn/batsir/raw/master/batsir.png)
 
 # Batsir
@@ -43,27 +44,70 @@ Batsir.create_and_start do
 end
 ```
 
-This example creates 2 stages, 'stage 1' and 'stage 2'. The first stage creates and AMQPAcceptor, 
+This example creates 2 stages, 'stage 1' and 'stage 2'. The first stage creates and AMQPAcceptor,
 that will connect to a AMQP Broker on localhost and will listen for messages on the 'some_queue' queue.
 When a message is received, the message will be offered to the SumFilter first. The result of the
 SumFilter is then sent to the #execute method of the AverageFilter. The result of this filter will
-than be sent as an AMQP message on the 'queue_2' queue.
+then be sent as an AMQP message on the 'queue_2' queue.
 
 The inbound AMQPAcceptor of the second stage will then receive the message and its filters will be
 invoked (the PrintFilter in this example).
 
+# Conditional Notifiers
+
+It is possible to create conditional notifiers. These accept a list of regular Notifiers which will
+send a message only if the provided condition evaluates to true. The condition is given as a String,
+which is evaluated in the context of a Proc at runtime. This Proc is always supplied with a 'message'
+parameter, which is available when the condition is evaluated.
+
+## Example of Conditional Notifier
+
+```ruby
+Batsir.create_and_start do
+  stage "stage 1" do
+    inbound do
+      acceptor AMQPAcceptor, :queue => 'some_queue', :host => 'localhost'
+    end
+    filter SumFilter
+    filter AverageFilter
+    outbound do
+      conditional do
+        notify_if "message.to_i > 2", AMQPNotifier, :queue => 'gt_2'
+        notify_if "message.to_i < 2", AMQPNotifier, :queue => 'lt_3'
+      end
+    end
+  end
+
+  stage "stage 2" do
+    inbound do
+      acceptor AMQPAcceptor, :queue => 'gt_2'
+    end
+    filter PrintFilter
+  end
+
+  stage "stage 3" do
+    inbound do
+      acceptor AMQPAcceptor, :queue => 'lt_3'
+    end
+  end
+end
+```
+
+In this example the message is sent to queue 'gt_2' if the integer value of the message is greater than 2,
+and to queue 'lt_2' when the integer value of the message is less than 2.
+
 # Sidekiq & Celluloid
 Batsir acts as both a Sidekiq server and client at the same time. When Batsir#create_and_start is invoked,
 Batsir will create Sidekiq workers on the fly, with instantiated filters on the workers. These workers will
 be deployed in the Sidekiq server, so that they will be available for processing. The workers also register
 themselves in a registry, where they can be requested using the stage name.
 
-The inbound acceptors will listen as a Celluloid Actor on the client side of Sidekiq. When a message is 
+The inbound acceptors will listen as a Celluloid Actor on the client side of Sidekiq. When a message is
 received, it will look up the corresponding StageWorker in the registry and it will invoke the
 StageWorker asynchronously using Sidekiq.
 
 ## Contributing to batsir
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project

data/Rakefile

@@ -9,28 +9,36 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'rake'
 
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rake'
 require 'jeweler'
+require 'batsir/version'
+
+version = Batsir::VERSION
+
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "batsir"
+  gem.version = version
   gem.homepage = "http://github.com/jwkoelewijn/batsir"
   gem.license = "MIT"
   gem.summary = %Q{Batsir is an execution platform for stage based operation queue execution}
-  gem.description = %Q{Batsir uses so called stages to define operation queues. These operation queus
- consist of several operations that will be executed one after the other. Each stage
- is defined by its name and the queue on which it will listen. Once a message is received
- on the queue, it is dispatched to a worker in a seperate thread that will pass the message
- to each operation in the operation queue.
- Operation queues can have 4 different operations, 1 common operation type, and 3 special 
- purpose operations: retrieval operations (which are always executed before all other operations),
- persistence operations (which are always executed after the common operations, but before the
- notification operations) and notification operations (which will always be executed last)
- This makes it possible to create chains of stages to perform tasks that depend on each
- other, but otherwise have a low coupling}
+  gem.description = %Q{Batsir uses so called stages to define operation queues. These operation queues
+    consist of several operations that will be executed one after the other. Each stage
+    is defined by its name and the queue on which it will listen. Once a message is received
+    on the queue, it is dispatched to a worker in a seperate thread that will pass the message
+    to each operation in the operation queue.
+    Operation queues can have 4 different operations, 1 common operation type, and 3 special
+    purpose operations: retrieval operations (which are always executed before all other operations),
+    persistence operations (which are always executed after the common operations, but before the
+    notification operations) and notification operations (which will always be executed last)
+    This makes it possible to create chains of stages to perform tasks that depend on each
+    other, but otherwise have a low coupling}
   gem.email = "jwkoelewijn@gmail.com"
-  gem.authors = ["J.W. Koelewijn"]
+  gem.authors = ["J.W. Koelewijn", "Bram de Vries"]
+  gem.extra_rdoc_files << "CHANGES.md"
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -44,12 +52,11 @@ end
 
 task :default => :spec
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "batsir #{version}"
   rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('CHANGES*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/batsir.gemspec

@@ -5,14 +5,15 @@
 
 Gem::Specification.new do |s|
   s.name = "batsir"
-  s.version = "0.1.0"
+  s.version = "0.3.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["J.W. Koelewijn"]
-  s.date = "2012-06-28"
-  s.description = "Batsir uses so called stages to define operation queues. These operation queus\n consist of several operations that will be executed one after the other. Each stage\n is defined by its name and the queue on which it will listen. Once a message is received\n on the queue, it is dispatched to a worker in a seperate thread that will pass the message\n to each operation in the operation queue.\n Operation queues can have 4 different operations, 1 common operation type, and 3 special \n purpose operations: retrieval operations (which are always executed before all other operations),\n persistence operations (which are always executed after the common operations, but before the\n notification operations) and notification operations (which will always be executed last)\n This makes it possible to create chains of stages to perform tasks that depend on each\n other, but otherwise have a low coupling"
+  s.authors = ["J.W. Koelewijn", "Bram de Vries"]
+  s.date = "2013-10-24"
+  s.description = "Batsir uses so called stages to define operation queues. These operation queues\n    consist of several operations that will be executed one after the other. Each stage\n    is defined by its name and the queue on which it will listen. Once a message is received\n    on the queue, it is dispatched to a worker in a seperate thread that will pass the message\n    to each operation in the operation queue.\n    Operation queues can have 4 different operations, 1 common operation type, and 3 special\n    purpose operations: retrieval operations (which are always executed before all other operations),\n    persistence operations (which are always executed after the common operations, but before the\n    notification operations) and notification operations (which will always be executed last)\n    This makes it possible to create chains of stages to perform tasks that depend on each\n    other, but otherwise have a low coupling"
   s.email = "jwkoelewijn@gmail.com"
   s.extra_rdoc_files = [
+    "CHANGES.md",
     "LICENSE.txt",
     "README.md"
   ]
@@ -20,43 +21,64 @@ Gem::Specification.new do |s|
     ".document",
     ".rspec",
     ".travis.yml",
+    "CHANGES.md",
     "Gemfile",
     "LICENSE.txt",
     "README.md",
     "Rakefile",
-    "VERSION",
     "batsir.gemspec",
     "batsir.png",
     "lib/batsir.rb",
     "lib/batsir/acceptors/acceptor.rb",
     "lib/batsir/acceptors/amqp_acceptor.rb",
     "lib/batsir/amqp.rb",
+    "lib/batsir/amqp_consumer.rb",
     "lib/batsir/chain.rb",
+    "lib/batsir/compiler/stage_worker_compiler.rb",
     "lib/batsir/config.rb",
+    "lib/batsir/dsl/conditional_notifier_declaration.rb",
     "lib/batsir/dsl/dsl_mappings.rb",
+    "lib/batsir/errors.rb",
     "lib/batsir/filter.rb",
     "lib/batsir/filter_queue.rb",
+    "lib/batsir/log.rb",
+    "lib/batsir/logger.rb",
     "lib/batsir/logo.rb",
     "lib/batsir/notifiers/amqp_notifier.rb",
+    "lib/batsir/notifiers/conditional_notifier.rb",
     "lib/batsir/notifiers/notifier.rb",
     "lib/batsir/registry.rb",
     "lib/batsir/stage.rb",
     "lib/batsir/stage_worker.rb",
+    "lib/batsir/strategies/retry_strategy.rb",
+    "lib/batsir/strategies/strategy.rb",
     "lib/batsir/transformers/field_transformer.rb",
     "lib/batsir/transformers/json_input_transformer.rb",
     "lib/batsir/transformers/json_output_transformer.rb",
     "lib/batsir/transformers/transformer.rb",
+    "lib/batsir/version.rb",
     "spec/batsir/acceptors/acceptor_spec.rb",
     "spec/batsir/acceptors/amqp_acceptor_spec.rb",
+    "spec/batsir/acceptors/shared_examples.rb",
+    "spec/batsir/amqp_spec.rb",
     "spec/batsir/chain_spec.rb",
+    "spec/batsir/config_spec.rb",
     "spec/batsir/dsl/chain_mapping_spec.rb",
+    "spec/batsir/dsl/conditional_notifier_mapping_spec.rb",
     "spec/batsir/dsl/stage_mapping_spec.rb",
     "spec/batsir/filter_queue_spec.rb",
     "spec/batsir/filter_spec.rb",
+    "spec/batsir/log_spec.rb",
+    "spec/batsir/logger_spec.rb",
     "spec/batsir/notifiers/amqp_notifier_spec.rb",
+    "spec/batsir/notifiers/conditional_notifier_spec.rb",
     "spec/batsir/notifiers/notifier_spec.rb",
+    "spec/batsir/notifiers/shared_examples.rb",
+    "spec/batsir/registry_spec.rb",
     "spec/batsir/stage_spec.rb",
     "spec/batsir/stage_worker_spec.rb",
+    "spec/batsir/strategies/retry_strategy_spec.rb",
+    "spec/batsir/strategies/strategy_spec.rb",
     "spec/batsir/support/bunny_mocks.rb",
     "spec/batsir/support/mock_filters.rb",
     "spec/batsir/transformers/field_transformer_spec.rb",
@@ -68,7 +90,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/jwkoelewijn/batsir"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.22"
+  s.rubygems_version = "1.8.25"
   s.summary = "Batsir is an execution platform for stage based operation queue execution"
 
   if s.respond_to? :specification_version then
@@ -77,28 +99,34 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<bundler>, ["> 1.0.0"])
       s.add_runtime_dependency(%q<jeweler>, [">= 0"])
-      s.add_runtime_dependency(%q<blockenspiel>, ["~> 0.4.3"])
-      s.add_runtime_dependency(%q<celluloid>, [">= 0"])
-      s.add_runtime_dependency(%q<sidekiq>, [">= 0"])
+      s.add_runtime_dependency(%q<rdoc>, [">= 0"])
+      s.add_runtime_dependency(%q<blockenspiel>, [">= 0.4.3"])
+      s.add_runtime_dependency(%q<celluloid>, ["~> 0.14.1"])
+      s.add_runtime_dependency(%q<sidekiq>, [">= 2.5.4"])
       s.add_runtime_dependency(%q<bunny>, [">= 0"])
       s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<log4r>, [">= 0"])
     else
       s.add_dependency(%q<bundler>, ["> 1.0.0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<blockenspiel>, ["~> 0.4.3"])
-      s.add_dependency(%q<celluloid>, [">= 0"])
-      s.add_dependency(%q<sidekiq>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<blockenspiel>, [">= 0.4.3"])
+      s.add_dependency(%q<celluloid>, ["~> 0.14.1"])
+      s.add_dependency(%q<sidekiq>, [">= 2.5.4"])
       s.add_dependency(%q<bunny>, [">= 0"])
       s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<log4r>, [">= 0"])
     end
   else
     s.add_dependency(%q<bundler>, ["> 1.0.0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<blockenspiel>, ["~> 0.4.3"])
-    s.add_dependency(%q<celluloid>, [">= 0"])
-    s.add_dependency(%q<sidekiq>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<blockenspiel>, [">= 0.4.3"])
+    s.add_dependency(%q<celluloid>, ["~> 0.14.1"])
+    s.add_dependency(%q<sidekiq>, [">= 2.5.4"])
     s.add_dependency(%q<bunny>, [">= 0"])
     s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<log4r>, [">= 0"])
   end
 end
 

data/lib/batsir/acceptors/acceptor.rb

@@ -18,27 +18,53 @@ module Batsir
         @transformer_queue << transformer
       end
 
+      #
       # This method is called automatically when the stage is
       # started, it is here that you set up the accepting
       # logic. Make sure that somewhere within this logic
       # the #start_filter_chain(msg) is called to start
-      # actual processing
+      # actual processing.
       #
       # Note that this method will be invoked asynchronously
       # using the Celluloid actor semantics.
+      #
       def start
-
+        raise NotImplementedError.new
       end
 
+      #
       # When a message is accepted by an Acceptor, this method
       # should be invoked with the received payload to start
-      # processing of the filter chain
+      # processing of the filter chain.
+      #
       def start_filter_chain(message)
         klazz = Batsir::Registry.get(stage_name)
+        message = transform(message)
+        klazz.perform_async(message) if klazz
+      end
+
+      #
+      # Call each of the transformers in the transformer_queue
+      # on the message, in order
+      #
+      def transform(message)
         transformer_queue.each do |transformer|
-          message = transformer.transform(message)
+          begin
+            message = transformer.transform(message)
+          rescue Batsir::Errors::TransformError => e
+            message = process_message_error(message, e)
+          end
         end
-        klazz.perform_async(message) if klazz
+        message
+      end
+
+      #
+      # This method is called after an error is thrown.
+      # Can be overridden to implement error handling.
+      # Returns a message
+      #
+      def process_message_error(message, error)
+        message
       end
     end
   end

data/lib/batsir/acceptors/amqp_acceptor.rb

@@ -4,16 +4,44 @@ module Batsir
   module Acceptors
     class AMQPAcceptor < Acceptor
       include Batsir::AMQP
-      def start
-        Bunny.run( bunny_options ) do |bunny|
-          q   = bunny.queue( queue )
-          exc = bunny.exchange( exchange )
-          q.bind( exc, :key => queue)
-          q.subscribe(:cancellator => cancellator) do |msg|
-            start_filter_chain(msg[:payload])
-          end
+      include Batsir::Log
+
+      attr_reader :consumer
+      attr_writer :consumer_source
+
+      def initialize(options={})
+        super
+        @bunny = Bunny.new(bunny_options).start
+        @channel = @bunny.channel
+        @q = @bunny.queue( queue, :durable => durable )
+        @x = @bunny.exchange( exchange )
+        @q.bind( @x, :routing_key => queue)
+
+        @consumer = consumer_source.call(self, @channel, @q)
+        @consumer.on_delivery() do |delivery_info, metadata, payload|
+          handle_delivery(payload)
         end
       end
+
+      def start
+        @q.subscribe_with(@consumer)
+      end
+
+      def handle_delivery(payload)
+        start_filter_chain(payload)
+      end
+
+      def process_message_error(message, error)
+        log.error error.message
+        nil
+      end
+
+    private
+
+      def consumer_source
+        @consumer_source ||= Batsir::AMQPConsumer.public_method(:new)
+      end
+
     end
   end
 end

data/lib/batsir/amqp.rb

@@ -5,8 +5,10 @@ module Batsir
     attr_accessor :port
     attr_accessor :username
     attr_accessor :password
+    attr_accessor :durable
     attr_accessor :vhost
     attr_accessor :exchange
+    attr_accessor :heartbeat
 
     def bunny_options
       {
@@ -14,32 +16,58 @@ module Batsir
         :port  => port,
         :user  => username,
         :pass  => password,
-        :vhost => vhost
+        :vhost => vhost,
+        :heartbeat => heartbeat
       }
     end
 
     def host
-      @host || 'localhost'
+      @host ||= Batsir::Config.fetch(:amqp_host, 'localhost')
     end
 
     def port
-      @port || 5672
+      @port ||= Batsir::Config.fetch(:amqp_port, 5672)
     end
 
     def username
-      @username || 'guest'
+      @username ||= Batsir::Config.fetch(:amqp_user, 'guest')
     end
 
     def password
-      @password || 'guest'
+      @password ||= Batsir::Config.fetch(:amqp_pass, 'guest')
     end
 
     def vhost
-      @vhost || '/'
+      @vhost ||= Batsir::Config.fetch(:amqp_vhost, '/')
     end
 
     def exchange
-      @exchange || 'amq.direct'
+      @exchange ||= Batsir::Config.fetch(:amqp_exchange, 'amq.direct')
+    end
+
+    def heartbeat
+      @heartbeat ||= Batsir::Config.fetch(:amqp_heartbeat, 0) # default to AMQP 0.8 heartbeat setting
+    end
+
+    def bunny_pool_size
+      @bunny_pool_size ||= Batsir::Config.ampq_pool_size
+    end
+
+    def durable
+      @durable ||= Batsir::Config.fetch(:amqp_durable, true)
+    end
+
+    def bunny_pool_key
+      "bunny_pool_for_#{host}_#{port}_#{vhost}"
+    end
+
+    def bunny_pool
+      @bunny_pool = Batsir::Registry.get(bunny_pool_key)
+      if !@bunny_pool
+        pool = ConnectionPool.new(:size => bunny_pool_size) { Bunny.new(bunny_options).start }
+        @bunny_pool = Batsir::Registry.register(bunny_pool_key, pool)
+      end
+      @bunny_pool
     end
   end
 end

data/lib/batsir/amqp_consumer.rb

@@ -0,0 +1,8 @@
+module Batsir
+  class AMQPConsumer < Bunny::Consumer
+    def initialize(acceptor, channel, queue)
+      super(channel, queue)
+      @acceptor = acceptor
+    end
+  end
+end

data/lib/batsir/compiler/stage_worker_compiler.rb

@@ -0,0 +1,86 @@
+module Batsir
+  module Compiler
+    class StageWorkerCompiler
+      attr_accessor :stage
+
+      def initialize(stage)
+        @stage = stage
+      end
+
+      def compile
+        klazz_name = "#{stage.name.capitalize.gsub(' ','')}Worker"
+        code = <<-EOF
+          class #{klazz_name}
+            def self.stage_name
+              "#{stage.name}"
+            end
+
+            def initialize
+              @filter_queue = self.class.filter_queue
+            end
+
+            def self.filter_queue
+              @filter_queue
+            end
+
+            def self.initialize_filter_queue
+              @filter_queue = Batsir::FilterQueue.new
+        EOF
+
+        stage.filter_declarations.each do |filter_declaration|
+          code << <<-EOF
+              @filter_queue.add #{filter_declaration.filter.to_s}.new(#{filter_declaration.options.to_s})
+          EOF
+        end
+
+        stage.conditional_notifiers.each do |conditional_notifier_declaration|
+          conditional_notifier_declaration.compile(code, self)
+        end
+
+        stage.notifiers.each do |notifier, options_set|
+          options_set.each do |options|
+            code << <<-EOF
+              notifier = #{notifier.to_s}.new(#{options.to_s})
+            EOF
+
+            self.add_transformers_to_notifier("notifier", code)
+
+            self.add_notifier("notifier", code)
+          end
+        end
+
+        code << <<-EOF
+            end
+
+            include Sidekiq::Worker
+            include Batsir::StageWorker
+          end
+
+          #{klazz_name}.sidekiq_options(:queue => Batsir::Config.sidekiq_queue)
+          #{klazz_name}
+        EOF
+        code
+      end
+
+      def add_transformers_to_notifier(notifier_name, code)
+        if stage.notifier_transformers.any?
+          stage.notifier_transformers.each do |transformer_declaration|
+            code << <<-EOF
+              #{notifier_name}.add_transformer #{transformer_declaration.transformer}.new(#{transformer_declaration.options.to_s})
+            EOF
+          end
+        else
+          code << <<-EOF
+              #{notifier_name}.add_transformer Batsir::Transformers::JSONOutputTransformer.new
+          EOF
+        end
+      end
+
+      def add_notifier(notifier_name, code)
+        code << <<-EOF
+              @filter_queue.add_notifier #{notifier_name}
+        EOF
+      end
+    end
+  end
+end