postbox 0.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Phunkwork
+
+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,17 @@
+# Postbox
+
+Prototype. Not to be described yet..
+
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add specs for it.
+* Commit, do not mess with rakefile, version, or history.
+* Send me a pull request. Bonus points for topic branches.
+
+
+## Copyright
+
+Copyright (c) 2010 Phunkwork. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "postbox"
+    gem.summary = %Q{An asynchronous http push library}
+    gem.description = %Q{Asynchronous http push library. Designed to handle lots of messages without interrupting the application flow.}
+    gem.email = "andreas@phunkwork.com"
+    gem.homepage = "http://github.com/phunkwork/postbox"
+    gem.authors = ["Andreas Wolff"]
+    gem.add_dependency "httparty" ,">= 0.5.2"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'reek/adapters/rake_task'
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "postbox #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO.md

@@ -0,0 +1,4 @@
+# TODO
+
+* Steak acceptance tests
+* Readme and Documentation 

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/postbox.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'httparty'
+
+module Postbox
+  autoload :HTTP,   'postbox/http'
+  autoload :Stack,  'postbox/stack'
+  autoload :Worker, 'postbox/worker'
+
+  extend self
+   
+  IS_IRB = $0 == 'irb'
+  
+  attr_writer :attempt_count, :attempt_delay
+  
+  def attempt_count
+    @attempt_count ||= 10
+  end 
+  
+  def attempt_delay
+    @attempt_delay ||= 6
+  end
+  
+  def post(url, params = {}, &callback)
+    item = Stack.push(url, params, &callback) 
+    Postbox::Worker.worker_thread.join if IS_IRB
+    return item
+  end
+  
+end

data/lib/postbox/http.rb

@@ -0,0 +1,26 @@
+module Postbox
+  module HTTP
+    extend self
+    include HTTParty
+    
+    def post_item(item)
+      begin
+        item.response = post(item.url, :body => item.params)
+        item.success = (200..299) === item.response.code
+        return true
+      rescue Timeout::Error, Errno::ECONNREFUSED, SocketError => error
+        item.last_error = error
+        item.last_attempt_at = Time.now
+        item.post_attempts += 1
+        return false
+      rescue => error
+        item.success = false
+        item.last_error = error
+        return false
+      ensure
+        item.callback.call(item) unless item.callback.nil?
+      end
+    end
+    
+  end
+end

data/lib/postbox/stack.rb

@@ -0,0 +1,39 @@
+require 'ostruct'
+
+module Postbox
+  module Stack
+    extend self
+    extend Enumerable
+    
+    def << (item)
+      stack << item
+    end
+    
+    def stack
+      @stack ||= []
+    end
+    
+    def each
+      stack.each { |e| yield(e) }
+    end
+    
+    def empty?
+      stack.empty?
+    end           
+    
+    def shift
+      stack.shift
+    end
+    
+    def size
+      stack.size
+    end
+    
+    def push(url, params = {}, &callback)
+      stack << item = OpenStruct.new(:url => url, :params => params, :callback => callback, :post_attempts => 0)
+      Postbox::Worker.wakeup
+      return item
+    end
+    
+  end
+end

data/lib/postbox/worker.rb

@@ -0,0 +1,50 @@
+module Postbox
+  module Worker
+    extend self
+    
+    attr_accessor :worker_thread
+    
+    def wakeup
+       if !@worker_thread.nil? && @worker_thread.alive?
+        @worker_thread.wakeup
+      else
+        @worker_thread = init
+      end
+    end
+    
+    def init
+      Thread.new do
+        loop do           
+          if Postbox::Stack.empty?
+            Thread.main.wakeup if Postbox::IS_IRB
+            sleep
+          else
+            unless process_item(Postbox::Stack.shift)
+              sleep 0.5
+            end
+          end
+        end
+      end
+    end
+    
+    def process_item(item)
+      unless next_attempt_allowed?(item) && (attempts_exceeded?(item) || HTTP::post_item(item))
+        Postbox::Stack << item
+        return false
+      end           
+      
+      true
+    end         
+    
+    
+    private
+    
+    def attempts_exceeded?(item)
+      item.post_attempts >= Postbox.attempt_count
+    end                                          
+    
+    def next_attempt_allowed?(item)
+      item.last_attempt_at.blank? || item.last_attempt_at + Postbox.attempt_delay <= Time.now
+    end
+  end
+end

data/spec/postbox/http_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Postbox::HTTP do
+  describe '.post_item' do
+    before(:each) do                                
+      @url = 'test.host/path'
+      @params = { :a => "a" }
+      @item = OpenStruct.new(:url => @url, :params => @params, :post_attempts => 0)
+    end
+    
+    it 'should post an item including params' do
+      Postbox::HTTP.should_receive(:post).with(@url, :body => @params)
+      Postbox::HTTP.post_item(@item)
+    end
+    
+    it 'should assign the response to the posted item' do
+      Postbox::HTTP.stub!(:post).and_return("<response>")
+      Postbox::HTTP.post_item(@item)
+      @item.response.should eql("<response>")
+    end
+    
+    it 'should give the posted item a true success attribute if the http status code is between 200 and 299' do
+      response = mock('Response', :code => 201)
+      Postbox::HTTP.stub!(:post).and_return(response)
+      Postbox::HTTP.post_item(@item)
+      @item.success.should be_true
+    end
+    
+    context 'handling errors' do                                      
+      it 'should return false' do
+        Postbox::HTTP.stub!(:post).and_raise("Error")
+        Postbox::HTTP.post_item(@item).should be_false
+      end
+      
+      context 'which should be temporary' do 
+        it 'should return false' do
+          error = Timeout::Error.new  
+          Postbox::HTTP.stub!(:post).and_raise(error)
+          Postbox::HTTP.post_item(@item).should be_false
+        end
+        
+        it 'should store the last error' do 
+          error = Timeout::Error.new  
+          Postbox::HTTP.stub!(:post).and_raise(error)
+          Postbox::HTTP.post_item(@item)
+          @item.last_error.should eql(error)
+        end
+        
+        it 'should store the time when the last attempt happend' do
+          Postbox::HTTP.stub!(:post).and_raise(Timeout::Error)
+          Postbox::HTTP.post_item(@item)
+          @item.last_attempt_at.should_not be_nil
+        end
+        
+        it 'should increase the attempts count if its a timeout error' do
+          Postbox::HTTP.stub!(:post).and_raise(Timeout::Error)
+          Postbox::HTTP.post_item(@item)
+          @item.post_attempts.should be(1)
+        end
+          
+        it 'should increse the attempts count if its a connection error' do
+          Postbox::HTTP.stub!(:post).and_raise(Errno::ECONNREFUSED)
+          Postbox::HTTP.post_item(@item)
+          @item.post_attempts.should be(1)
+        end
+
+        it 'should increse the attempts count if its a connection error' do
+          Postbox::HTTP.stub!(:post).and_raise(SocketError)
+          Postbox::HTTP.post_item(@item)
+          @item.post_attempts.should be(1)
+        end
+      end
+      
+      it 'should mark the posted item as failed (success == false)' do
+        Postbox::HTTP.stub!(:post).and_raise("Error")
+        Postbox::HTTP.post_item(@item)
+        @item.success.should be_false
+      end
+      
+      it 'should assign the error to the item' do
+        error = StandardError.new
+        Postbox::HTTP.stub!(:post).and_raise(error)
+        Postbox::HTTP.post_item(@item)
+        @item.last_error.should eql(error)
+      end
+    end
+    
+    context 'handling callbacks' do
+      before(:each) do
+        @item.callback = lambda {}
+        response = mock('Response', :code => 201)
+        Postbox::HTTP.stub!(:post).and_return(response)
+      end                 
+      
+      it 'should call the block if it exists' do
+        @item.callback.should_receive(:call)
+        Postbox::HTTP.post_item(@item)
+      end
+      
+      it 'should pass the item to the block' do
+        @item.callback.should_receive(:call).with(@item)
+        Postbox::HTTP.post_item(@item)
+      end
+      
+      it 'should be called even if an error occurs' do
+        Postbox::HTTP.stub!(:post).and_raise("Error")
+        @item.callback.should_receive(:call)
+        Postbox::HTTP.post_item(@item)
+      end
+    end
+  end
+  
+end

data/spec/postbox/stack_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Postbox::Stack do
+  
+  describe '.<<' do
+    it 'should put an item on to the stack' do
+      item = mock('item')
+      Postbox::Stack << item
+      Postbox::Stack.should include(item) 
+    end
+  end
+  
+  describe '.stack' do
+    it 'should return an array' do
+      Postbox::Stack.stack.should be_kind_of(Array)
+    end                                           
+    
+    it 'should init the array only once' do
+      stack = Array.new
+      Postbox::Stack.send(:instance_variable_set, :@stack, stack)
+      Postbox::Stack.stack.should be(stack)
+    end
+  end
+  
+  describe '.each' do
+    it 'should proxy calls to the stack object' do
+      stack = []
+      Postbox::Stack.stub!(:stack).and_return(stack)
+      stack.should_receive(:each)
+      Postbox::Stack.each
+    end
+  end                            
+  
+  describe '.push' do
+    before(:each) do
+     Postbox::Worker.stub!(:wakeup)
+    end         
+    
+    it 'should put items on the stack' do
+      callback = lambda { "test" }
+      item = Postbox::Stack.push( 'localhost/123', { :fu => 'ba' }, &callback )
+      item.url.should eql('localhost/123')
+      item.params.should eql({ :fu => 'ba' })
+      item.callback.should eql(callback)
+    end
+    
+    it 'should wake up the worker after adding an item' do
+      Postbox::Worker.should_receive(:wakeup)
+      Postbox::Stack.push( 'localhost/123' )
+    end
+  end
+end

data/spec/postbox/worker_spec.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Postbox::Worker do
+
+  describe '.wakeup' do
+    before(:each) do
+      @worker_thread = mock('WorkerThread')
+      @worker_thread.stub!(:wakeup)
+    end                            
+    
+    it 'should initialize the worker' do
+      Postbox::Worker.should_receive(:init).and_return(@worker_thread)
+      Postbox::Worker.wakeup
+    end
+    
+    context 'with living thread' do  
+      before(:each) do
+        @worker_thread.stub!(:alive?).and_return(true)
+      end
+      
+      it 'should not initialize the worker if its already alive' do
+        Postbox::Worker.worker_thread = @worker_thread
+        Postbox::Worker.should_not_receive(:init)
+        Postbox::Worker.wakeup
+      end
+    
+      it 'should wakeup the worker thread' do
+        Postbox::Worker.worker_thread = @worker_thread
+        @worker_thread.should_receive(:wakeup)
+        Postbox::Worker.wakeup
+      end
+    end
+    
+    context 'with dead thread' do
+      it 'should init the worker' do
+        @worker_thread.stub!(:alive?).and_return(false)
+        Postbox::Worker.worker_thread = @worker_thread
+        Postbox::Worker.should_receive(:init)
+        Postbox::Worker.wakeup
+      end
+    end
+  end
+  
+  describe '.process_item' do                              
+    before(:each) do
+      Postbox.stub!(:attempt_count).and_return(5)
+      @item = mock('Item', :post_attempts => 0, :last_attempt_at => nil)
+    end                   
+    
+    it 'should send the item' do
+      Postbox::HTTP.should_receive(:post_item).with(@item)
+      Postbox::Worker.process_item(@item)
+    end
+    
+    context 'handling failed submissions' do
+      before(:each) do                 
+        Postbox::HTTP.stub!(:post_item).and_return(false)
+      end
+      
+      it 'should put the item back on the stack' do
+        Postbox::Stack.should_receive(:<<).with(@item)
+        Postbox::Worker.process_item(@item)
+      end
+      
+      it 'should not put the item back on stack if then max attempt count has been reached' do
+        @item.stub!(:post_attempts).and_return(10)
+        Postbox::Stack.should_not_receive(:<<).with(@item)
+        Postbox::Worker.process_item(@item)
+      end      
+    end
+    
+    context 'handling delays between submissions' do
+      before(:each) do                                    
+        Postbox.stub!(:attempt_delay).and_return(600)
+        @item.stub!(:last_attempt_at).and_return(Time.now)
+      end
+      
+      it 'should not send the item if the timespan between the last-send-timestamp and now is to short' do
+        Postbox::HTTP.should_not_receive(:post_item)
+        Postbox::Worker.process_item(@item)
+      end
+      
+      it 'should put items back on the stack if sending is not allowed at the moment' do
+        Postbox::Stack.should_receive(:<<).with(@item)
+        Postbox::Worker.process_item(@item)
+      end
+    end
+  end
+end

data/spec/postbox_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Postbox do
+
+  describe 'configuration attributes' do
+    it 'should have default values' do
+      Postbox::attempt_count.should eql(10)
+      Postbox::attempt_delay.should eql(6)
+    end
+    
+    it 'should allow overriding the default values' do
+      Postbox::attempt_count = 5
+      Postbox::attempt_delay = 3
+      Postbox::attempt_count.should eql(5)
+      Postbox::attempt_delay.should eql(3)
+    end
+    
+  end
+  
+  describe '.post' do
+    it 'should push a post job to the stack' do
+      Postbox::Stack.should_receive(:push).with('localhost/api', anything())
+      Postbox.post "localhost/api"
+    end
+    
+    it 'should accept optional params' do
+      Postbox::Stack.should_receive(:push).with(anything(), { :fu => "ba", "ba" => :fu })
+      Postbox.post "localhost/api", :fu => "ba", "ba" => :fu
+    end
+    
+    it 'should take an optional block' do
+      callback = lambda { "test" }
+      Postbox::Stack.should_receive(:push).with(anything(), anything(), &callback)
+      Postbox.post "localhost/api", {}, &callback
+    end
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'postbox'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: postbox
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Andreas Wolff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-30 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 5
+        - 2
+        version: 0.5.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+description: Asynchronous http push library. Designed to handle lots of messages without interrupting the application flow.
+email: andreas@phunkwork.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- VERSION
+- lib/postbox.rb
+- lib/postbox/http.rb
+- lib/postbox/stack.rb
+- lib/postbox/worker.rb
+- spec/postbox/http_spec.rb
+- spec/postbox/stack_spec.rb
+- spec/postbox/worker_spec.rb
+- spec/postbox_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/phunkwork/postbox
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.3.7
+signing_key: 
+specification_version: 3
+summary: An asynchronous http push library
+test_files: 
+- spec/postbox/http_spec.rb
+- spec/postbox/stack_spec.rb
+- spec/postbox/worker_spec.rb
+- spec/postbox_spec.rb
+- spec/spec_helper.rb