surety 0.1.7

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    surety (0.1.0)
+      activerecord (>= 3.0)
+      activesupport (>= 3.0)
+      resque (>= 1.19.0)
+      state_machine (>= 1.0.0)
+      yajl-ruby (~> 0.8.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.11)
+      activesupport (= 3.0.11)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.11)
+      activemodel (= 3.0.11)
+      activesupport (= 3.0.11)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.11)
+    arel (2.0.10)
+    builder (2.1.2)
+    i18n (0.5.0)
+    multi_json (1.0.4)
+    mysql2 (0.2.7)
+    rack (1.4.0)
+    rack-protection (1.2.0)
+      rack
+    redis (2.2.2)
+    redis-namespace (1.0.3)
+      redis (< 3.0.0)
+    resque (1.19.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.0.2)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    sinatra (1.3.2)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    state_machine (1.1.1)
+    tilt (1.3.3)
+    tzinfo (0.3.31)
+    vegas (0.1.8)
+      rack (>= 1.0.0)
+    yajl-ruby (0.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mysql2 (= 0.2.7)
+  surety!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Monica McArthur
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+Surety
+============
+
+A lightweight guaranteed-delivery messaging system.
+
+
+Dependency Notes
+================
+
+* Surety uses ActiveRecord to persist the message requests in order to provide transactional, guaranteed-delivery requests. Requires ActiveRecord 3.0.0 or higher.
+* Surety uses Resque to underpin the message processing/retry loop. Requires Resque 1.19.0 or higher.
+
+
+Usage / Examples
+================
+
+A simple class that can send a message for guaranteed delivery:
+
+    class TestGenerator
+      include Surety::Generator
+    
+      def some_method
+        self.send_message(message_content)
+      end
+    end
+    
+
+On the server side, to start up the loop to process messages:
+
+  Surety::Processor.request_next
+
+    
+Configuration
+=============
+
+Both the prefix for the ActiveRecord database connection name (as specified in database.yml) and the class to which Surety delegates messages for processing after pulling them off the queue are configurable.
+
+Example configuration (from a sample config/initializers/surety.rb file)
+
+Surety::Configuration.database_prefix = 'surety_'
+Surety::Configuration.message_processing_delegate = MessageDistributor
+
+
+Install
+=======
+
+### As a gem
+
+    $ gem install surety
+
+
+Acknowledgements
+================
+
+Copyright (c) 2012 Monica McArthur, released under the MIT license.
+
+Thanks to Ryan and Steve for arguing that this gem was necessary... it is.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the surety gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/generators/install_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+
+module Surety
+  class InstallGenerator < Rails::Generators::Base
+
+    source_root File.join(File.dirname(__FILE__), 'templates')
+
+    def manifest
+      copy_file "20120104151700_create_messages.rb", "db/migrate/20120104151700_create_messages.rb"
+    end
+  end
+end

data/lib/generators/templates/20120104151700_create_messages.rb

@@ -0,0 +1,21 @@
+class CreateMessages < ActiveRecord::Migration
+  def self.up
+    create_table :messages do |t|
+      t.string :message_content
+      t.string :state
+      t.integer :processing_attempt_count, :default => 0
+      t.datetime :processing_started_at
+      t.datetime :completed_at
+      t.integer :failure_count, :default => 0
+      t.datetime :failed_at
+      t.text :last_exception
+      t.timestamps
+    end
+
+    add_index :messages, [:state, :failed_at]
+  end
+
+  def self.down
+    drop_table :messages
+  end
+end

data/lib/surety/configuration.rb

@@ -0,0 +1,12 @@
+module Surety
+  module Configuration
+    extend self
+    
+    attr_accessor :database_prefix, :message_processing_delegate
+    
+    def database
+      "#{database_prefix}#{ENV['RAILS_ENV'] || Rails.env}"
+    end
+    
+  end
+end

data/lib/surety/generator.rb

@@ -0,0 +1,14 @@
+module Surety
+  module Generator
+    extend ActiveSupport::Concern
+    
+    module InstanceMethods
+      
+      def send_message(message_content)
+        Surety::Message.generate_message(message_content)
+      end
+      
+    end
+  
+  end
+end

data/lib/surety/message.rb

@@ -0,0 +1,78 @@
+module Surety
+  class Message < ActiveRecord::Base
+    require 'state_machine'
+    establish_connection Surety::Configuration.database
+    
+    scope :needs_processing, lambda {
+      puts ActiveRecord::Base.default_timezone
+      puts ActiveRecord::Base.default_timezone.to_s=='utc'
+      db_time = Time.now.send(ActiveRecord::Base.default_timezone.to_s=='utc' ? :utc : :localtime)
+      puts db_time
+      {:conditions=>"(messages.state='unprocessed') or (messages.state='failed' and messages.failed_at<'#{(db_time-10.minutes).strftime('%Y-%m-%d %H:%M:%S')}')",
+      :order => :created_at, :limit=>1}
+    }
+
+    def self.generate_message(message_content)
+      self.create(:message_content=>message_content)
+    end
+    
+    def self.get_next_for_processing
+      next_message = nil
+      ActiveRecord::Base.transaction do
+        next_message = self.needs_processing.first
+        next_message.begin_processing! if next_message
+      end
+      next_message
+    end
+
+    state_machine :state, :initial => :unprocessed do
+      state :unprocessed
+      state :processing
+      state :completed
+      state :failed
+      
+      event :begin_processing do
+        transition [:unprocessed, :failed] => :processing
+      end
+      
+      event :complete_processing do
+        transition :processing => :completed
+      end
+      
+      event :fail_processing do
+        transition :processing => :failed
+      end
+
+      before_transition :on => :begin_processing, :do => :reserve
+      before_transition :on => :complete_processing, :do => :record_completion
+      before_transition :on => :fail_processing, :do => :record_failure
+    end
+    
+    def reserve
+      self.processing_started_at = Time.now
+      self.processing_attempt_count = self.processing_attempt_count+1
+    end
+    
+    def process
+      begin
+        Surety::Configuration.message_processing_delegate.process(self)
+        self.complete_processing!
+      rescue Exception => ex
+        self.last_exception = ex
+        self.fail_processing!
+        raise ex
+      end
+    end
+    
+    def record_completion
+      self.completed_at = Time.now
+      self.last_exception = nil
+    end
+
+    def record_failure
+      self.failed_at = Time.now
+      self.failure_count = self.failure_count+1
+    end
+
+  end
+end

data/lib/surety/processor.rb

@@ -0,0 +1,29 @@
+module Surety
+  class Processor
+    
+    @queue = :surety_messages
+    
+    def self.perform
+      message = nil
+      puts "[Surety::Processor]: Handling surety message"
+      begin
+        message = Surety::Message.get_next_for_processing
+        puts "[Surety::Processor]: Found message #{message.inspect}"
+        message.process if message
+      rescue Exception => ex
+        puts "[Surety::Processor]: error #{ex.to_s}"
+        puts "[Surety::Processor]: #{ex.backtrace.join("\n")}"
+        raise ex
+      ensure
+        sleep 5 if message.nil?
+        request_next
+      end
+        
+    end
+    
+    def self.request_next
+      Resque.enqueue(self)
+    end
+    
+  end
+end

data/lib/surety.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require 'resque'
+module Surety
+  autoload :Configuration,  'surety/configuration'
+  autoload :Generator,      'surety/generator'
+  autoload :Message,        'surety/message'
+  autoload :Processor,      'surety/processor'
+end

data/surety.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name              = 'surety'
+  s.version           = '0.1.7'
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.summary           = 'A lightweight guaranteed-delivery messaging system.'
+  s.homepage          = ''
+  s.email             = 'monica@revolutionprep.com'
+  s.authors           = ['Monica McArthur']
+
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_dependency('yajl-ruby', '~> 0.8.2')
+  s.add_dependency('resque', '>= 1.19.0')
+  s.add_dependency('activesupport', '>= 3.0')
+  s.add_dependency('activerecord', '>= 3.0')
+  s.add_dependency('state_machine', '>=1.0.0')
+
+  s.add_development_dependency('mysql2', '0.2.7')
+
+  s.description       = <<-DESC
+    A lightweight guaranteed-delivery messaging system.
+  DESC
+end

data/test/configuration_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  def setup
+    Surety::Configuration.database_prefix = 'surety_'
+  end
+  
+  def test_database_configuration
+    assert Surety::Configuration.database=='surety_test'
+  end
+  
+end

data/test/database.yml

@@ -0,0 +1,13 @@
+test:
+  adapter: mysql2
+  host: localhost
+  username: root
+  password: root
+  database: surety_test
+
+surety_test:
+  adapter: mysql2
+  host: localhost
+  username: root
+  password: root
+  database: surety_test

data/test/fixtures/test_delegate.rb

@@ -0,0 +1,18 @@
+class TestDelegate
+  def self.process(message)
+    #puts "processing #{message.inspect}"
+    if message.message_content.match('Good')
+      @@processing_result = "Success processing #{message.message_content}"
+    elsif message.message_content.match('Bad')
+      @@processing_result = "Failure processing #{message.message_content}"
+      raise Exception.new('opps')
+    else
+      @@processing_result = 'What?'
+    end
+    #puts "result is #{@@processing_result}"
+  end
+  
+  def self.processing_result
+    @@processing_result
+  end
+end

data/test/fixtures/test_generator.rb

@@ -0,0 +1,7 @@
+class TestGenerator
+  include Surety::Generator
+  
+  def generate_test_message
+    send_message('This is a test')
+  end
+end

data/test/generator_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class GeneratorTest < Test::Unit::TestCase
+
+  def setup
+    Surety::Configuration.database_prefix = 'surety_'
+  end
+  
+  def test_message_generation
+    TestGenerator.new.generate_test_message
+    message = Surety::Message.first
+    assert message.present?
+    assert_message_matches(message, 
+      {
+        :message_content=>'This is a test',
+        :state => 'unprocessed',
+        :processing_attempt_count => 0,
+        :failure_count => 0,
+        :processing_started_at => nil,
+        :completed_at => nil,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+  end
+  
+end

data/test/message_test.rb

@@ -0,0 +1,284 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class MessageTest < Test::Unit::TestCase
+
+  def setup
+    Surety::Configuration.database_prefix = 'surety_'
+    @message = Surety::Message.generate_message('Testing message')
+  end
+  
+  def test_database_name
+    assert Surety::Message.new.connection.current_database=='surety_test'
+  end
+  
+  def test_message_creation
+    assert_message_matches(@message, 
+      {
+        :message_content=>'Testing message',
+        :state => 'unprocessed',
+        :processing_attempt_count => 0,
+        :failure_count => 0,
+        :processing_started_at => nil,
+        :completed_at => nil,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+  end
+  
+  def test_message_processing
+    @message.begin_processing!
+    assert_message_matches(@message, 
+      {
+        :message_content=>'Testing message',
+        :state => 'processing',
+        :processing_attempt_count => 1,
+        :failure_count => 0,
+        :completed_at => nil,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+      assert_in_delta(@message.processing_started_at, Time.now, 5)
+  end
+    
+  def test_message_completion
+    @message.begin_processing!
+    @message.complete_processing!
+    assert_message_matches(@message, 
+      {
+        :message_content=>'Testing message',
+        :state => 'completed',
+        :processing_attempt_count => 1,
+        :failure_count => 0,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+      assert_in_delta(@message.processing_started_at, Time.now, 5)
+      assert_in_delta(@message.completed_at, Time.now, 5)
+  end
+  
+  def test_message_failure
+    @message.begin_processing!
+    @message.fail_processing!
+    assert_message_matches(@message, 
+      {
+        :message_content=>'Testing message',
+        :state => 'failed',
+        :processing_attempt_count => 1,
+        :failure_count => 1,
+        :completed_at => nil,
+        :last_exception => nil
+      })
+      assert_in_delta(@message.processing_started_at, Time.now, 5)
+      assert_in_delta(@message.failed_at, Time.now, 5)
+  end
+  
+  def test_message_retry
+    @message.begin_processing!
+    @message.fail_processing!
+    message_first_fail = Time.now
+    sleep(10)
+    @message.begin_processing!
+    @message.complete_processing!
+    assert_message_matches(@message, 
+      {
+        :message_content=>'Testing message',
+        :state => 'completed',
+        :processing_attempt_count => 2,
+        :failure_count => 1,
+        :last_exception => nil
+      })
+      assert_in_delta(@message.processing_started_at, Time.now, 5)
+      assert_in_delta(@message.completed_at, Time.now, 5)
+      assert_in_delta(@message.failed_at, message_first_fail, 5)
+  end
+  
+  def test_bad_transitions
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.fail_processing!
+    }
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.complete_processing!
+    }
+    @message.begin_processing!
+    @message.fail_processing!
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.complete_processing!
+    }
+    @message.begin_processing!
+    @message.complete_processing!
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.fail_processing!
+    }
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.complete_processing!
+    }
+    assert_raise(StateMachine::InvalidTransition) {
+      @message.begin_processing!
+    }
+  end
+  
+  def test_needs_processing
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Message 1')
+    @message2 = Surety::Message.generate_message('Message 2')
+    @message3 = Surety::Message.generate_message('Message 3')
+    @message4 = Surety::Message.generate_message('Message 4')
+    @message5 = Surety::Message.generate_message('Message 5')
+    @message6 = Surety::Message.generate_message('Message 6')
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 2',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message3.begin_processing!
+    @message3.complete_processing!
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 4',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.reload
+    @message1.fail_processing!
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 5',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.failed_at = Time.now-40.minutes
+    @message1.save
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 2,
+      :failure_count => 1,
+      :completed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+  end
+  
+  def test_gets_next_for_processing
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Message 1')
+    @message2 = Surety::Message.generate_message('Message 2')
+    @message3 = Surety::Message.generate_message('Message 3')
+    @message4 = Surety::Message.generate_message('Message 4')
+    @message5 = Surety::Message.generate_message('Message 5')
+    @message6 = Surety::Message.generate_message('Message 6')
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 2',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message3.begin_processing!
+    @message3.complete_processing!
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 4',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.reload
+    @message1.fail_processing!
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 5',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.failed_at = Time.now-40.minutes
+    @message1.save
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 2,
+      :failure_count => 1,
+      :completed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+  end
+  
+  def test_no_next_message
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Message 1')
+    @message1.begin_processing!
+    @message1.complete_processing!
+    message = Surety::Message.get_next_for_processing
+    assert message.nil?
+  end
+  
+end

data/test/message_timezone_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class MessageTimezoneTest < Test::Unit::TestCase
+
+  def setup
+    Surety::Configuration.database_prefix = 'surety_'
+    ActiveRecord::Base.default_timezone = :utc
+    @message = Surety::Message.generate_message('Testing message')
+  end
+  
+  def test_needs_processing_failure_timeout_when_active_record_using_utc
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Message 1')
+    @message2 = Surety::Message.generate_message('Message 2')
+    message = Surety::Message.needs_processing.first
+    message.begin_processing!
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.reload
+    @message1.fail_processing!
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 2',
+      :state => 'processing',
+      :processing_attempt_count => 1,
+      :failure_count => 0,
+      :completed_at => nil,
+      :failed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+    @message1.failed_at = Time.now-40.minutes
+    @message1.save
+    message = Surety::Message.get_next_for_processing
+    assert message.present?
+    assert_message_matches(message, {
+      :message_content=>'Message 1',
+      :state => 'processing',
+      :processing_attempt_count => 2,
+      :failure_count => 1,
+      :completed_at => nil,
+      :last_exception => nil
+    })
+    assert_in_delta(message.processing_started_at, Time.now, 5)
+  end
+
+end

data/test/processor_test.rb

@@ -0,0 +1,126 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+
+class ProcessorTest < Test::Unit::TestCase
+
+  def setup
+    $success = $lock_failed = $lock_expired = 0
+    Resque.redis.namespace = nil
+    Resque.redis.flushall
+    Resque.redis.namespace = 'test_surety'
+    Surety::Configuration.database_prefix = 'surety_'
+    Surety::Configuration.message_processing_delegate = TestDelegate
+  end
+  
+  def test_request_next
+    Surety::Processor.request_next
+    assert Resque.redis.llen('queue:surety_messages')==1
+  end
+  
+  def test_perform_successful
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Good Message 1')
+    @message2 = Surety::Message.generate_message('Message 2')
+    Surety::Processor.request_next
+    Resque::Worker.new(:surety_messages).process
+    @message1.reload
+    assert_message_matches(@message1, 
+      {
+        :message_content=>'Good Message 1',
+        :state => 'completed',
+        :processing_attempt_count => 1,
+        :failure_count => 0,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+    assert_in_delta(@message1.processing_started_at, Time.now, 5)
+    assert_in_delta(@message1.completed_at, Time.now, 5)
+    assert TestDelegate.processing_result=='Success processing Good Message 1'
+    assert Resque.redis.llen('queue:surety_messages')==1
+  end
+  
+  def test_perform_fail
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Bad Message 1')
+    @message2 = Surety::Message.generate_message('Message 2')
+    Surety::Processor.request_next
+    Resque::Worker.new(:surety_messages).process
+    @message1.reload
+    assert_message_matches(@message1, 
+      {
+        :message_content=>'Bad Message 1',
+        :state => 'failed',
+        :processing_attempt_count => 1,
+        :failure_count => 1,
+        :completed_at => nil,
+      })
+    assert_in_delta(@message1.processing_started_at, Time.now, 5)
+    assert_in_delta(@message1.failed_at, Time.now, 5)
+    assert @message1.last_exception.present?
+    assert TestDelegate.processing_result=='Failure processing Bad Message 1'
+    assert Resque.redis.llen('queue:surety_messages')==1
+  end
+  
+  def test_perform_multiple
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Good Message 1')
+    @message2 = Surety::Message.generate_message('Bad Message 2')
+    @message3 = Surety::Message.generate_message('Good Message 3')
+    @message4 = Surety::Message.generate_message('Left Alone Message 4')
+    Surety::Processor.request_next
+    Resque::Worker.new(:surety_messages).process
+    assert TestDelegate.processing_result=='Success processing Good Message 1'
+    Resque::Worker.new(:surety_messages).process
+    assert TestDelegate.processing_result=='Failure processing Bad Message 2'
+    Resque::Worker.new(:surety_messages).process
+    assert TestDelegate.processing_result=='Success processing Good Message 3'
+    assert Resque.redis.llen('queue:surety_messages')==1
+    @message1.reload
+    assert_message_matches(@message1, 
+      {
+        :message_content=>'Good Message 1',
+        :state => 'completed',
+        :processing_attempt_count => 1,
+        :failure_count => 0,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+    assert_in_delta(@message1.processing_started_at, Time.now, 5)
+    assert_in_delta(@message1.completed_at, Time.now, 5)
+    @message2.reload
+    assert_message_matches(@message2, 
+      {
+        :message_content=>'Bad Message 2',
+        :state => 'failed',
+        :processing_attempt_count => 1,
+        :failure_count => 1,
+        :completed_at => nil,
+      })
+    assert_in_delta(@message2.processing_started_at, Time.now, 5)
+    assert_in_delta(@message2.failed_at, Time.now, 5)
+    assert @message2.last_exception.present?
+    assert Resque.redis.llen('queue:surety_messages')==1
+    @message3.reload
+    assert_message_matches(@message3, 
+      {
+        :message_content=>'Good Message 3',
+        :state => 'completed',
+        :processing_attempt_count => 1,
+        :failure_count => 0,
+        :failed_at => nil,
+        :last_exception => nil
+      })
+    assert_in_delta(@message3.processing_started_at, Time.now, 5)
+    assert_in_delta(@message3.completed_at, Time.now, 5)
+  end
+  
+  def test_perform_nothin_in_queue
+    Surety::Message.new.connection.execute("truncate table messages")
+    @message1 = Surety::Message.generate_message('Message 1')
+    @message1.begin_processing!
+    @message1.complete_processing!
+    Surety::Processor.request_next
+    Resque::Worker.new(:surety_messages).process
+    assert Resque.redis.llen('queue:surety_messages')==1
+  end
+  
+end

data/test/redis-test.conf

@@ -0,0 +1,132 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes
+
+# Use object sharing. Can save a lot of memory if you have many common
+# string in your dataset, but performs lookups against the shared objects
+# pool so it uses more CPU and can be a bit slower. Usually it's a good
+# idea.
+#
+# When object sharing is enabled (shareobjects yes) you can use
+# shareobjectspoolsize to control the size of the pool used in order to try
+# object sharing. A bigger pool size will lead to better sharing capabilities.
+# In general you want this value to be at least the double of the number of
+# very common strings you have in your dataset.
+#
+# WARNING: object sharing is experimental, don't enable this feature
+# in production before of Redis 1.0-stable. Still please try this feature in
+# your development environment so that we can test it better.
+#shareobjects no
+#shareobjectspoolsize 1024

data/test/schema.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :messages, :force => true do |t|
+    t.column :message_content, :string
+    t.column :state, :string
+    t.column :processing_attempt_count, :integer, :default => 0
+    t.column :processing_started_at, :datetime
+    t.column :completed_at, :datetime
+    t.column :failure_count, :integer, :default => 0
+    t.column :failed_at, :datetime
+    t.column :last_exception, :text
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,70 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TESTING = true
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'resque'
+require 'state_machine'
+
+require 'surety'
+
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.configurations = config
+require 'mysql2'
+ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+
+load(File.dirname(__FILE__) + "/schema.rb")
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures"
+  self.use_transactional_fixtures = false
+  self.use_instantiated_fixtures = false
+  fixtures :all
+end
+
+
+# make sure we can run redis
+if !system('which redis-server')
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+# start our own redis when the tests start,
+# kill it when they end
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
+
+  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts 'Killing test redis server...'
+  `rm -f #{dir}/dump.rdb`
+  Process.kill('KILL', pid.to_i)
+  exit exit_code
+end
+
+puts 'Starting redis for testing at localhost:9736...'
+`redis-server #{dir}/redis-test.conf`
+Resque.redis = '127.0.0.1:9736'
+Resque.redis.namespace = 'test_surety'
+
+Dir.glob(File.expand_path(dir + '/fixtures/*')).each { |filename| require filename }
+
+def assert_message_matches(message, attrs)
+  attrs.each_key {|key|
+    #puts "checking message key: #{key} #{message.send(key.to_sym)} #{attrs[key]}"
+    assert message.send(key.to_sym)==attrs[key]
+  }
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification 
+name: surety
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 7
+  version: 0.1.7
+platform: ruby
+authors: 
+- Monica McArthur
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 91
+        segments: 
+        - 1
+        - 19
+        - 0
+        version: 1.19.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: state_machine
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 2
+        - 7
+        version: 0.2.7
+  type: :development
+  version_requirements: *id006
+description: "    A lightweight guaranteed-delivery messaging system.\n"
+email: monica@revolutionprep.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/install_generator.rb
+- lib/generators/templates/20120104151700_create_messages.rb
+- lib/surety.rb
+- lib/surety/configuration.rb
+- lib/surety/generator.rb
+- lib/surety/message.rb
+- lib/surety/processor.rb
+- surety.gemspec
+- test/configuration_test.rb
+- test/database.yml
+- test/fixtures/test_delegate.rb
+- test/fixtures/test_generator.rb
+- test/generator_test.rb
+- test/message_test.rb
+- test/message_timezone_test.rb
+- test/processor_test.rb
+- test/redis-test.conf
+- test/schema.rb
+- test/test_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A lightweight guaranteed-delivery messaging system.
+test_files: 
+- test/configuration_test.rb
+- test/database.yml
+- test/fixtures/test_delegate.rb
+- test/fixtures/test_generator.rb
+- test/generator_test.rb
+- test/message_test.rb
+- test/message_timezone_test.rb
+- test/processor_test.rb
+- test/redis-test.conf
+- test/schema.rb
+- test/test_helper.rb