dispatch-rider 1.4.0 → 1.4.2

data/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# only add dev/test gems here, runtime gems should go in the gemspec
+
+# Base
+gem "bundler"
+gem "rake"
+
+# Gem Stuff
+gem 'rubygems-tasks'
+gem 'github_changelog_generator'
+gem 'yard'
+
+# Testing
+gem "rspec", "~> 2.0"
+gem 'rspec-its', "~> 1.0"
+
+# CI
+gem "travis-lint"
+
+# Dev/Debugging
+gem "byebug", platform: :ruby_20, require: !ENV['CI']
+gem "aws-sdk", "~> 1"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Suman Mukherjee
+Copyright (c) 2015 PayrollHero Pte. Ltd.
 
 MIT License
 

data/README.md

@@ -257,7 +257,7 @@ class ReadNews < DispatchRider::Handlers::Base
       puts headline
     end
   end
-  
+
   def retry_timeout
     10.minutes
   end
@@ -277,7 +277,7 @@ extend_timeout will tell the queue you wish to hold this item longer.
 class LongRunning < DispatchRider::Handlers::Base
   def process(body)
     my_loop.each do |item|
-      
+
       #... do some work ...
       extend_timeout(1.hour)
     end
@@ -344,6 +344,35 @@ DispatchRider.config do |config|
   config.error_handler = DispatchRider::AirbrakeErrorHandler
 end
 ```
+## Deployment
+
+In order to deploy a new version of the gem into the wild ...
+
+You will need to configure your github api token for the changelog.
+
+Generate a new token for changelogs [here](https://github.com/settings/tokens/new).
+
+add:
+
+```bash
+export CHANGELOG_GITHUB_TOKEN=YOUR_CHANGELOG_API_TOKEN
+```
+
+somewhere in your shell init. (ie .zshrc or simillar)
+
+
+```bash
+vim lib/dispatch-rider/version.rb
+# set the new version
+rake gemspec
+# commit any changed files (should be only version and the gemspec)
+# name your commit with the version number eg: "1.8.0"
+rake release
+# to push the gem to rubygems.org
+rake changelog
+# commit the changed changelog
+# name your commit with the version again eg: "changelog for 1.8.0"
+```
 
 ## Contributing
 
@@ -357,7 +386,7 @@ end
 
 ### Licence
 
-Copyright (c) 2013 Suman Mukherjee
+Copyright (c) 2015 PayrollHero Pte. Ltd.
 
 MIT License
 

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new
+task :doc => :yard
+
+desc "Updates the changelog"
+task :changelog do
+  sh "github_changelog_generator payrollhero/dispatch-rider"
+end

data/dispatch-rider.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/dispatch-rider/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = "dispatch-rider"
+  gem.version = DispatchRider::VERSION
+
+  gem.summary = %q{
+    Messaging system that is customizable based on which
+    queueing system we are using.
+  }
+  gem.description = %q{
+    Messaging system based on the reactor pattern.
+
+    You can publish messages to a queue and then a demultiplexer
+    runs an event loop which pops items from the queue and hands
+    it over to a dispatcher.
+
+    The dispatcher hands over the message to the appropriate
+    handler.
+
+    You can choose your own queueing service.
+  }
+  gem.license = "MIT"
+  gem.authors = [
+    "Suman Mukherjee",
+    "Dane Natoli",
+    "Piotr Banasik",
+    "Ronald Maravilla",
+  ]
+  gem.email = [
+    "piotr@payrollhero.com",
+    "rmaravilla@payrollhero.com",
+  ]
+  gem.homepage = "https://github.com/payrollhero/dispatch-rider"
+  gem.files = `git ls-files`.split($/)
+  gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency('activesupport', ">= 0")
+  gem.add_runtime_dependency('activemodel', ">= 0")
+  gem.add_runtime_dependency('daemons', ">= 0")
+  gem.add_runtime_dependency('retries', ">= 0")
+end

data/lib/dispatch-rider/notification_services/aws_sns.rb

@@ -1,3 +1,4 @@
+require 'retries'
 # This is a basic implementation of the Notification service using Amazon SNS.
 # The expected usage is as follows :
 #   notification_service = DispatchRider::NotificationServices::AwsSns.new
@@ -15,6 +16,14 @@ module DispatchRider
         Registrars::SnsChannel
       end
 
+      def publish(options)
+        channels(options[:to]).each do |channel|
+          with_retries(max_retries: 10, rescue: AWS::Errors::MissingCredentialsError) do
+            channel.publish(serialize(message(options[:message])))
+          end
+        end
+      end
+
       # not really happy with this, but the notification service registrar system is way too rigid to do this cleaner
       # since you only can have one notifier for the whole service, but you need to create a new one for each region
       def channel(name)

data/lib/dispatch-rider/version.rb

@@ -1,4 +1,4 @@
 # This file specifies the current version of the gem.
 module DispatchRider
-  VERSION = "1.4.0"
+  VERSION = "1.4.2"
 end

data/spec/fixtures/handlers/another_test_handler.rb

@@ -0,0 +1,2 @@
+class AnotherTestHandler < DispatchRider::Handlers::Base
+end

data/spec/fixtures/handlers/test_handler.rb

@@ -0,0 +1,2 @@
+class TestHandler < DispatchRider::Handlers::Base
+end

data/spec/lib/dispatch-rider/airbrake_error_handler_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe DispatchRider::AirbrakeErrorHandler do
+
+  describe ".call" do
+    let(:message){ DispatchRider::Message.new(subject: "TestMessage", body: "foo" )}
+    let(:exception){ Exception.new("Something went terribly wrong") }
+
+    example do
+      Airbrake.should_receive(:notify).with(exception, controller: "DispatchRider", action: "TestMessage", parameters: { subject: "TestMessage", body: "foo" }, cgi_data: anything)
+
+      described_class.call(message, exception)
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/callbacks/access_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe DispatchRider::Callbacks::Access do
+  describe "#invoke" do
+
+    let(:callback_a1) { proc { |x| x.call } }
+    let(:callback_a2) { proc { |x| x.call } }
+    let(:callback_a3) { proc { |x| x.call } }
+    let(:callbacks_a) { [callback_a1, callback_a2, callback_a3] }
+
+    let(:callback_b1) { proc { |x| x.call } }
+    let(:callbacks_b) { [callback_b1] }
+
+    let(:storage) { DispatchRider::Callbacks::Storage.new }
+    let(:action) { proc { } }
+
+    subject { described_class.new(storage) }
+
+    before do
+      callbacks_a.each do |cb|
+        storage.around :event1, cb
+      end
+      callbacks_b.each do |cb|
+        storage.around :event2, cb
+      end
+    end
+
+    example "a bunch of handlers" do
+      callback_a1.should_receive(:call).once.and_call_original
+      callback_a2.should_receive(:call).once.and_call_original
+      callback_a3.should_receive(:call).once.and_call_original
+      callback_b1.should_not_receive(:call)
+
+      action.should_receive(:call).once.and_call_original
+
+      subject.invoke(:event1, &action)
+    end
+
+    example "single handler" do
+      callback_a1.should_not_receive(:call)
+      callback_a2.should_not_receive(:call)
+      callback_a3.should_not_receive(:call)
+      callback_b1.should_receive(:call).once.and_call_original
+
+      action.should_receive(:call).once.and_call_original
+
+      subject.invoke(:event2, &action)
+    end
+
+    example "no handlers" do
+      callback_a1.should_not_receive(:call)
+      callback_a2.should_not_receive(:call)
+      callback_a3.should_not_receive(:call)
+      callback_b1.should_not_receive(:call)
+
+      action.should_receive(:call).once.and_call_original
+
+      subject.invoke(:event3, &action)
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/callbacks/storage_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe DispatchRider::Callbacks::Storage do
+
+  subject{ described_class.new }
+
+  describe "adding callbacks" do
+
+    let!(:log) { [] }
+    let(:actual) { proc { log << :actual } }
+
+    describe "#around" do
+      example do
+        subject.around(:initialize) do |job|
+          log << :abefore
+          job.call
+          log << :aafter
+        end
+        subject.for(:initialize).first[actual]
+        log.should == [:abefore, :actual, :aafter]
+      end
+    end
+
+    describe "#before" do
+      example do
+        subject.before(:initialize) { log << :before }
+        subject.for(:initialize).first[actual]
+        log.should == [:before, :actual]
+      end
+    end
+
+    describe "#after" do
+      example do
+        subject.after(:initialize) { log << :after }
+        subject.for(:initialize).first[actual]
+        log.should == [:actual, :after]
+      end
+    end
+
+  end
+
+
+end

data/spec/lib/dispatch-rider/configuration_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe DispatchRider::Configuration do
+
+  subject{ described_class.new }
+
+  describe "defaults" do
+    example do
+      subject.handler_path.should =~ /\/app\/handlers/
+      subject.error_handler.should == DispatchRider::DefaultErrorHandler
+      subject.queue_kind.should == :file_system
+      subject.queue_info.should == { path: "tmp/dispatch-rider-queue" }
+      subject.subscriber.should == DispatchRider::Subscriber
+    end
+  end
+
+  describe "#before" do
+    example do
+      subject.should respond_to(:before)
+    end
+  end
+
+  describe "#after" do
+    example do
+      subject.should respond_to(:after)
+    end
+  end
+
+  describe "#around" do
+    example do
+      subject.should respond_to(:around)
+    end
+  end
+
+  describe "#handlers" do
+    before :each do
+      subject.handler_path = "./spec/fixtures/handlers"
+    end
+
+    it "loads the files and converts their names to symbols" do
+      subject.handlers.should include(:test_handler, :another_test_handler)
+    end
+  end
+  
+  describe "#default_retry_timeout" do
+    it "sets the default timeout" do
+      subject.default_retry_timeout = 60
+      TestHandler.instance_methods.should include(:retry_timeout)
+      #Need to do this so that all the other tests don't have this as default!
+      DispatchRider::Handlers::Base.send(:remove_method,:retry_timeout)
+    end
+  end
+
+  describe "#logger" do
+
+    describe "default" do
+      example { subject.logger.should be_kind_of(Logger) }
+    end
+
+    example { subject.should respond_to(:logger) }
+  end
+
+  describe "#logger=" do
+    let(:new_logger) { double(:logger) }
+
+    example { subject.should respond_to(:logger=) }
+
+    example do
+      subject.logger = new_logger
+      subject.logger.should == new_logger
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/default_error_handler_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe DispatchRider::DefaultErrorHandler do
+
+  describe ".call" do
+    let(:exception){ Exception.new("Something went terribly wrong") }
+    example do
+      expect{
+        described_class.call("Error", exception)
+      }.to raise_exception exception
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/demultiplexer_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe DispatchRider::Demultiplexer, :nodb => true do
+  class TestHandler < DispatchRider::Handlers::Base
+    def process(options)
+      raise "OMG!!!" if options["raise_exception"]
+    end
+  end
+
+  let(:dispatcher) do
+    dispatcher = DispatchRider::Dispatcher.new
+    dispatcher.register(:test_handler)
+    dispatcher
+  end
+
+  let(:queue) do
+    DispatchRider::QueueServices::Simple.new
+  end
+
+  let(:message){ DispatchRider::Message.new(:subject => "test_handler", :body => {}) }
+
+  let(:demultiplexer_thread) do
+    demultiplexer
+    thread = Thread.new do
+      demultiplexer.start
+    end
+    thread[:demultiplexer] = demultiplexer
+    thread
+  end
+
+  let(:error_handler){ ->(message, exception){ raise exception }}
+
+  subject(:demultiplexer) { DispatchRider::Demultiplexer.new(queue, dispatcher, error_handler) }
+
+  describe "#initialize" do
+    it "should assign the queue" do
+      demultiplexer.queue.should be_empty
+    end
+
+    it "should assign the dispatcher" do
+      demultiplexer.dispatcher.fetch(:test_handler).should eq(TestHandler)
+    end
+  end
+
+  describe "#start" do
+    after do
+      demultiplexer_thread[:demultiplexer].stop
+      demultiplexer_thread.join
+    end
+
+    context "when the queue is not empty" do
+
+      before do
+        queue.push message
+      end
+
+      it "should be sending the message to the dispatcher" do
+        demultiplexer.should_receive(:dispatch_message).with(message).at_least(:once)
+        demultiplexer_thread.run
+        sleep 0.01 # give it a chance to process the job async before killing the demux
+      end
+
+      # THIS ALSO TESTS THAT THE JOB IS NOT RUN MULTIPLE TIMES
+      # IF THIS FAILS, BE CAREFUL NOT TO INTRODUCE BUGS
+      it "should call the correct handler" do
+        TestHandler.any_instance.should_receive(:process).with(message.body).at_least(1).times
+        demultiplexer_thread.run
+        sleep 0.01 # give it a chance to process the job async before killing the demux
+      end
+    end
+
+    context "when the queue is empty" do
+      it "should not be sending any message to the dispatcher" do
+        demultiplexer.should_receive(:dispatch_message).exactly(0).times
+        demultiplexer_thread.run
+      end
+    end
+
+    context "when the handler crashes" do
+      before do
+        message.body = { "raise_exception" => true }
+        queue.push message
+      end
+
+      it "should call the error handler" do
+        error_handler.should_receive(:call).at_least(:once).and_return(true)
+        queue.should_not_receive(:delete)
+        demultiplexer_thread.run
+        sleep 0.01 # give it a chance to process the job async before killing the demux
+      end
+    end
+
+    context "when the queue crashes" do
+      before do
+        queue.stub(:pop){ raise "OMG!!!"}
+      end
+
+      it "should call the error handler" do
+        error_handler.should_receive(:call).once
+        demultiplexer_thread.run
+
+        sleep 0.01 # give it a chance to process the job async before killing the demux
+      end
+    end
+  end
+
+  describe ".stop" do
+    it "should stop the demultiplexer" do
+      demultiplexer_thread.run
+      demultiplexer_thread.should be_alive # looper should be looping
+      demultiplexer_thread[:demultiplexer].stop
+      demultiplexer_thread.join
+      demultiplexer_thread.should_not be_alive # looper should close the loop
+    end
+  end
+
+end