quebert 0.0.0

data/.document

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

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,14 @@
+source :rubygems
+
+gem 'json'
+gem 'daemons'
+gem 'optitron'
+gem 'beanstalk-client'
+
+group :test do
+  gem 'rspec'
+  gem 'ZenTest'
+  gem 'ruby-debug'
+  gem 'activerecord'
+  gem 'sqlite3-ruby'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Brad Gessler
+
+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.rdoc

@@ -0,0 +1,113 @@
+= Quebert
+
+async_observer is great, but is dated and doesn't really support running jobs outside of the async_send idiom. Quebert is an attempt to mix how jobs are run in other popular worker queue frameworks, like resque and dj, with async_observer so that you can have it both ways.
+
+A worker queue framework designed around Beanstalk. Features include:
+
+= Features
+
+* [x] Multiple back-ends (InProcess, Sync, and Beanstalk)
+* [x] Rails/ActiveRecord integration similar to async_observer
+* [ ] Pluggable exception handling (for Hoptoad integration)
+* [ ] Reliable daemonization with pidfile support
+
+[x] = Completed, [ ] = Not Started
+
+= How to use
+
+There are two ways to enqueue jobs with Quebert: through the Job itself, provided you set a default back-end for the job, or put it on the backend.
+
+== Jobs
+
+Quebert includes a Job class so you can implement how you want certain types of Jobs performed.
+    
+    Quebert.backend = Quebert::Backend::InProcess.new
+    
+    class WackyMathWizard < Quebert::Job
+      def perform(*nums)
+        nums.inject(0){|sum, n| sum = sum + n}
+      end
+    end
+
+You can either drop a job in a queue:
+
+    Quebert.backend.put WackyMathWizard, 1, 2, 3
+
+Or drop it in right from the job:
+
+    WackyMathWizard.enqueue 4, 5, 6
+
+Then perform the jobs!
+
+    Quebert.backend.reserve.perform # => 6
+    Quebert.backend.reserve.perform # => 15
+
+== Async Sender
+
+Take any ol' class and include the Quebert::AsyncSender.
+
+    Quebert.backend = Quebert::Backend::InProcess.new
+
+    class Greeter
+      include Quebert::AsyncSender
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def sleep_and_greet(time_of_day)
+        sleep 10000 # Sleeping, get it?
+        "Oh! Hi #{name}! Good #{time_of_day}."
+      end
+      
+      def self.budweiser_greeting(name)
+        "waaazup #{name}!"
+      end
+    end
+    
+    walmart_greeter = Greeter.new("Brad")
+
+Remember the send method in ruby?
+
+    walmart_greeter.send(:sleep_and_greet, "morning")
+    # ... time passes, you wait as greeter snores obnoxiously ...
+    # => "Oh! Hi Brad! Good morning."
+
+What if the method takes a long time to run and you want to queue it? async_send it!
+
+    walmart_greeter.async_send(:sleep_and_greet, "morning")
+    # ... do some shopping and come back later when the dude wakes up
+    
+Quebert figures out how to *serialize the class, throw it on a worker queue, re-instantiate it on the other side, and finish up the work.
+
+    Quebert.backend.reserve.perform # => "Oh! Hi Brad! Good morning."
+    # ... Sorry dude! I'm shopping already
+    
+Does it work on Class methods? Yeah, that was easier than making instance methods work:
+
+    Quebert.async_send(:budweiser_greeting, "Corey")
+    Quebert.backend.reserve.perform # => "waazup Corey!"
+
+* Only basic data types are included for serialization. Serializers may be customized to include support for different types.
+
+= License 
+
+Copyright (c) 2010 Brad Gessler
+
+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/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "quebert"
+    gem.summary = %Q{A worker queue framework built around beanstalkd}
+    gem.description = %Q{A worker queue framework built around beanstalkd}
+    gem.email = "brad@bradgessler.com"
+    gem.homepage = "http://github.com/bradgessler/quebert"
+    gem.authors = ["Brad Gessler"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency "json"
+    gem.add_dependency "daemons"
+    gem.add_dependency "beanstalk-client"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  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
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "quebert #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/quebert.rb

@@ -0,0 +1,29 @@
+$:.unshift File.join(File.dirname(__FILE__), 'quebert')
+
+module Quebert
+  autoload :Configuration,  'quebert/configuration'
+  autoload :Job,            'quebert/job'
+  autoload :Consumer,       'quebert/consumer'
+  autoload :Backend,        'quebert/backend'
+  autoload :Support,        'quebert/support'
+  autoload :Worker,         'quebert/worker'
+  autoload :Daemonizable,   'quebert/daemonizing'
+  autoload :AsyncSender,    'quebert/async_sender'
+  
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias_method :config, :configuration
+
+    # Registry for quebert backends
+    def backends
+      @backends ||= {}
+    end
+  end
+  
+  # Register built-in Quebert backends
+  Backend.register :beanstalk,  Backend::Beanstalk
+  Backend.register :in_process, Backend::InProcess
+  Backend.register :sync,       Backend::Sync
+end

data/lib/quebert/async_sender.rb

@@ -0,0 +1,99 @@
+module Quebert
+  module AsyncSender
+    
+    # Perform jobs on Object methods (not instances)
+    module Object
+      class ObjectJob < Job
+        def perform(const, meth, args)
+          Support.constantize(const).send(meth, *args)
+        end
+      end
+      
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+      
+      module ClassMethods
+        def async_send(meth, *args)
+          ObjectJob.enqueue(self.name, meth, args)
+        end
+      end
+    end
+    
+    # Perform jobs on instances of classes
+    module Instance
+      class InstanceJob < Job
+        def perform(klass, init_args, meth, args)
+          Support.constantize(klass).new(init_args).send(meth, *args)
+        end
+      end
+      
+      def self.included(base)
+        # Its not as simple as including initialize in a class, we
+        # have to do some tricks to make it work so we can put the include
+        # before the initialize method as opposed to after. Ah, and thanks PivotalLabs for this.
+        base.extend ClassMethods
+        base.overwrite_initialize
+        base.instance_eval do
+          def method_added(name)
+            return if name != :initialize
+            overwrite_initialize
+          end
+        end
+      end
+      
+      def initialize_with_async_sender(*args)
+        initialize_without_async_sender(*(@_init_args = args))
+      end
+      
+      module ClassMethods
+        def overwrite_initialize
+          class_eval do
+            unless method_defined?(:initialize_with_async_sender)
+              define_method(:initialize_with_async_sender) do
+                initialize_without_async_sender
+              end
+            end
+            
+            if instance_method(:initialize) != instance_method(:initialize_with_async_sender)
+              alias_method :initialize_without_async_sender, :initialize
+              alias_method :initialize, :initialize_with_async_sender
+            end
+          end
+        end
+      end
+      
+      def async_send(meth, *args)
+        InstanceJob.enqueue(self.class.name, @_init_args, meth, args)
+      end
+    end
+    
+    # Extend a class with both the object and instance async_send
+    module Class
+      def self.included(base)
+        base.send(:include, AsyncSender::Object)
+        base.send(:include, AsyncSender::Instance)
+      end
+    end
+    
+    module ActiveRecord
+      class RecordJob < Job
+        def perform(klass, id, meth, args)
+          Support.constantize(klass).find(id).send(meth, *args)
+        end
+      end
+      
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :include, AsyncSender::Object
+      end
+      
+      module InstanceMethods
+        def async_send(meth, *args)
+          RecordJob.enqueue(self.class.name, id, meth, args)
+        end
+      end
+    end
+    
+  end
+end

data/lib/quebert/backend.rb

@@ -0,0 +1,11 @@
+module Quebert
+  module Backend
+    autoload :InProcess,  'quebert/backend/in_process.rb'
+    autoload :Beanstalk,  'quebert/backend/beanstalk.rb'
+    autoload :Sync,       'quebert/backend/sync.rb'
+    
+    def self.register(name, backend)
+      Quebert.backends[name.to_sym] = backend
+    end
+  end
+end

data/lib/quebert/backend/beanstalk.rb

@@ -0,0 +1,35 @@
+require 'beanstalk-client'
+
+module Quebert
+  module Backend
+    
+    # Manage jobs on a Beanstalk queue out of process
+    class Beanstalk < Beanstalk::Pool
+      def put(job, *args)
+        super Job.to_json(job, *args)
+      end
+      
+      def reserve_with_consumer
+        Consumer::Beanstalk.new(reserve_without_consumer, self)
+      end
+      alias :reserve_without_consumer :reserve
+      alias :reserve :reserve_with_consumer
+      
+      # For testing purposes... I think there's a better way to do this though.
+      def drain!
+        while peek_ready do
+          reserve_without_consumer.delete
+        end
+        while job = peek_buried do
+          last_conn.kick 1 # what? Why the 1? it kicks them all?
+          reserve_without_consumer.delete
+        end
+      end
+      
+      def self.configure(opts={})
+        opts[:host] ||= '127.0.0.1:11300'
+        new(opts[:host], opts[:tube])
+      end
+    end
+  end
+end

data/lib/quebert/backend/in_process.rb

@@ -0,0 +1,14 @@
+module Quebert
+  module Backend
+    # Drops jobs on an array in-process.
+    class InProcess < Array
+      def put(job, *args)
+        unshift Job.to_json(job, *args)
+      end
+      
+      def reserve
+        json = pop and Consumer::Base.new(Job.from_json(json))
+      end
+    end
+  end
+end

data/lib/quebert/backend/sync.rb

@@ -0,0 +1,11 @@
+module Quebert
+  module Backend
+    # Run the job syncronously. This is typically used in a testing environment
+    # or could be used as a fallback if other backends fail to initialize
+    class Sync
+      def put(job, *args)
+        Consumer::Base.new(job.new(args)).perform
+      end
+    end
+  end
+end

data/lib/quebert/configuration.rb

@@ -0,0 +1,16 @@
+module Quebert
+  class Configuration
+    attr_accessor :backend
+    
+    def self.from_hash(hash)
+      hash, config = Support.symbolize_keys(hash), new
+      # Find out backend from the registry and configure
+      if backend = Quebert.backends[hash.delete(:backend).to_sym]
+        # If the backend supports configuration, do it!
+        p backend
+        config.backend = backend.respond_to?(:configure) ? backend.configure(Support.symbolize_keys(hash)) : backend.new
+      end
+      config
+    end
+  end
+end