quebert 0.0.0

data/lib/quebert/consumer.rb

@@ -0,0 +1,9 @@
+module Quebert
+  # The basic glue between a job and the specific queue implementation. This
+  # handles exceptions that may be thrown by the Job and how the Job should
+  # be put back on the queue, if at all.
+  module Consumer
+    autoload :Base,       'quebert/consumer/base'
+    autoload :Beanstalk,  'quebert/consumer/beanstalk'
+  end
+end

data/lib/quebert/consumer/base.rb

@@ -0,0 +1,21 @@
+module Quebert
+  module Consumer
+    # The most Consumer. Doesn't even accept the queue as an argument because there's nothing
+    # a job can do to be rescheduled, etc.
+    class Base
+      attr_reader :job
+      
+      def initialize(job)
+        @job = job
+      end
+      
+      def perform
+        begin
+          job.perform(*job.args)
+        rescue Job::Action
+          # Nothing to do chief!
+        end
+      end
+    end
+  end
+end

data/lib/quebert/consumer/beanstalk.rb

@@ -0,0 +1,30 @@
+module Quebert
+  module Consumer
+    # Handle interactions between a job and a Beanstalk queue.
+    class Beanstalk < Base
+      attr_reader :beanstalk_job, :queue, :job
+      
+      def initialize(beanstalk_job, queue)
+        @beanstalk_job, @queue = beanstalk_job, queue
+        @job = Job.from_json(beanstalk_job.body)
+      end
+      
+      def perform
+        begin
+          result = job.perform(*job.args)
+          beanstalk_job.delete
+          result
+        rescue Job::Delete
+          beanstalk_job.delete
+        rescue Job::Release
+          beanstalk_job.release
+        rescue Job::Bury
+          beanstalk_job.bury
+        rescue Exception => e
+          beanstalk_job.bury
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/quebert/daemonizing.rb

@@ -0,0 +1,144 @@
+require 'etc'
+require 'daemons'
+require 'fileutils'
+
+module Process
+  # Returns +true+ the process identied by +pid+ is running.
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::EPERM
+    true
+  rescue Errno::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+module Quebert
+  module Daemonizable
+    attr_accessor :pid_file, :log_file
+    
+    PidFileExist = Class.new(RuntimeError)
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    def daemonize
+      raise ArgumentError, 'You must specify a pid_file to daemonize' unless pid_file
+      
+      remove_stale_pid_file
+      
+      pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+      # HACK we need to create the directory before daemonization to prevent a bug under 1.9
+      #      ignoring all signals when the directory is created after daemonization.
+      FileUtils.mkdir_p File.dirname(pid_file)
+      # Daemonize.daemonize(File.expand_path(@log_file), "quebert worker")
+      Daemonize.daemonize(File.expand_path(@log_file), "quebert")
+      Dir.chdir(pwd)
+      write_pid_file
+    end
+    
+    def pid
+      File.exist?(pid_file) ? open(pid_file).read.to_i : nil
+    end
+    
+    # Register a proc to be called to restart the server.
+    def on_restart(&block)
+      @on_restart = block
+    end
+    
+    # Restart the server.
+    def restart
+      if @on_restart
+        log '>> Restarting ...'
+        stop
+        remove_pid_file
+        @on_restart.call
+        exit!
+      end
+    end
+    
+    module ClassMethods
+      # Send a QUIT or INT (if timeout is +0+) signal the process which
+      # PID is stored in +pid_file+.
+      # If the process is still running after +timeout+, KILL signal is
+      # sent.
+      def kill(pid_file, timeout=60)
+        if timeout == 0
+          send_signal('INT', pid_file, timeout)
+        else
+          send_signal('QUIT', pid_file, timeout)
+        end
+      end
+      
+      # Restart the server by sending HUP signal.
+      def restart(pid_file)
+        send_signal('HUP', pid_file)
+      end
+      
+      # Send a +signal+ to the process which PID is stored in +pid_file+.
+      def send_signal(signal, pid_file, timeout=60)
+        if pid = read_pid_file(pid_file)
+          Logging.log "Sending #{signal} signal to process #{pid} ... "
+          Process.kill(signal, pid)
+          Timeout.timeout(timeout) do
+            sleep 0.1 while Process.running?(pid)
+          end
+        else
+          Logging.log "Can't stop process, no PID found in #{pid_file}"
+        end
+      rescue Timeout::Error
+        Logging.log "Timeout!"
+        force_kill pid_file
+      rescue Interrupt
+        force_kill pid_file
+      rescue Errno::ESRCH # No such process
+        Logging.log "process not found!"
+        force_kill pid_file
+      end
+      
+      def force_kill(pid_file)
+        if pid = read_pid_file(pid_file)
+          Logging.log "Sending KILL signal to process #{pid} ... "
+          Process.kill("KILL", pid)
+          File.delete(pid_file) if File.exist?(pid_file)
+        else
+          Logging.log "Can't stop process, no PID found in #{pid_file}"
+        end
+      end
+      
+      def read_pid_file(file)
+        if File.file?(file) && pid = File.read(file)
+          pid.to_i
+        else
+          nil
+        end
+      end
+    end
+    
+  protected
+    def remove_pid_file
+      File.delete(pid_file) if pid_file && File.exists?(pid_file)
+    end
+    
+    def write_pid_file
+      log ">> Writing PID to #{pid_file}"
+      open(pid_file,"w") { |f| f.write(Process.pid) }
+      File.chmod(0644, pid_file)
+    end
+    
+    # If PID file is stale, remove it.
+    def remove_stale_pid_file
+      if File.exist?(pid_file)
+        if pid && Process.running?(pid)
+          raise PidFileExist, "#{pid_file} already exists, seems like it's already running (process ID: #{pid}). " +
+                              "Stop the process or delete #{pid_file}."
+        else
+          log ">> Deleting stale PID file #{pid_file}"
+          remove_pid_file
+        end
+      end
+    end
+  end
+end

data/lib/quebert/job.rb

@@ -0,0 +1,62 @@
+require 'json'
+
+module Quebert
+  class Job
+    attr_reader :args
+    
+    NotImplemented = Class.new(StandardError)
+    
+    Action  = Class.new(Exception)
+    
+    Bury    = Class.new(Action)
+    Delete  = Class.new(Action)
+    Release = Class.new(Action)
+    
+    def initialize(args=[])
+      @args = args.dup.freeze
+    end
+    
+    def perform(*args)
+      raise NotImplemented
+    end
+    
+    def self.enqueue(*args)
+      backend.put(self, *args)
+    end
+    
+    def to_json
+      self.class.to_json(self)
+    end
+    
+    def self.to_json(job, *args)
+      args, job = job.args, job.class if job.respond_to?(:args)
+      JSON.generate('job' => job.name, 'args' => args)
+    end
+    
+    def self.from_json(json)
+      if data = JSON.parse(json)
+        Support.constantize(data['job']).new(data['args'])
+      end
+    end
+    
+    def self.backend=(backend)
+      @backend = backend
+    end
+    def self.backend
+      @backend || Quebert.configuration.backend
+    end
+    
+  protected
+    def delete!
+      raise Delete
+    end
+    
+    def release!
+      raise Release
+    end
+    
+    def bury!
+      raise Bury
+    end
+  end
+end

data/lib/quebert/support.rb

@@ -0,0 +1,28 @@
+module Quebert
+  module Support
+    # Borrowed from Rails ActiveSupport
+    def self.constantize(camel_cased_word) #:nodoc:
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+    
+    def self.symbolize_keys(hash)
+      map_keys(hash, :to_sym)
+    end
+    
+    def self.stringify_keys(hash)
+      map_keys(hash, :to_s)
+    end
+    
+  private
+    def self.map_keys(hash, meth)
+      hash.inject({}){|h, (k,v)| h[k.send(meth)] = v; h; }
+    end
+  end
+end

data/lib/quebert/worker.rb

@@ -0,0 +1,29 @@
+require 'logger'
+
+module Quebert
+  class Worker
+    attr_accessor :exception_handler, :log_file, :backend
+    
+    include Quebert::Daemonizable
+    
+    def initialize
+      yield self if block_given?
+    end
+    
+    # Start the worker backend and intercept exceptions if a handler is provided
+    def start
+      while job = backend.reserve do
+        begin
+          job.perform
+        rescue Exception => e
+          exception_handler ? exception_handler.call(e) : raise(e)
+        end
+      end
+    end
+    
+  protected
+    def log(message)
+      puts message
+    end
+  end
+end

data/quebert.gemspec

@@ -0,0 +1,92 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{quebert}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brad Gessler"]
+  s.date = %q{2010-10-03}
+  s.description = %q{A worker queue framework built around beanstalkd}
+  s.email = %q{brad@bradgessler.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/quebert.rb",
+     "lib/quebert/async_sender.rb",
+     "lib/quebert/backend.rb",
+     "lib/quebert/backend/beanstalk.rb",
+     "lib/quebert/backend/in_process.rb",
+     "lib/quebert/backend/sync.rb",
+     "lib/quebert/configuration.rb",
+     "lib/quebert/consumer.rb",
+     "lib/quebert/consumer/base.rb",
+     "lib/quebert/consumer/beanstalk.rb",
+     "lib/quebert/daemonizing.rb",
+     "lib/quebert/job.rb",
+     "lib/quebert/support.rb",
+     "lib/quebert/worker.rb",
+     "quebert.gemspec",
+     "spec/async_sender_spec.rb",
+     "spec/backend_spec.rb",
+     "spec/configuration_spec.rb",
+     "spec/consumer_spec.rb",
+     "spec/job_spec.rb",
+     "spec/jobs.rb",
+     "spec/quebert_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/worker_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/bradgessler/quebert}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A worker queue framework built around beanstalkd}
+  s.test_files = [
+    "spec/async_sender_spec.rb",
+     "spec/backend_spec.rb",
+     "spec/configuration_spec.rb",
+     "spec/consumer_spec.rb",
+     "spec/job_spec.rb",
+     "spec/jobs.rb",
+     "spec/quebert_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/worker_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<daemons>, [">= 0"])
+      s.add_runtime_dependency(%q<beanstalk-client>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<daemons>, [">= 0"])
+      s.add_dependency(%q<beanstalk-client>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<daemons>, [">= 0"])
+    s.add_dependency(%q<beanstalk-client>, [">= 0"])
+  end
+end
+

data/spec/async_sender_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'active_record'
+
+describe AsyncSender::Class do
+  
+  before(:all) do
+    @q = Backend::InProcess.new
+    Quebert::AsyncSender::Object::ObjectJob.backend = @q
+    Quebert::AsyncSender::Instance::InstanceJob.backend = @q
+  end
+  
+  class Greeter
+    include AsyncSender::Class
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def hi(desc)
+      "hi #{@name}, you look #{desc}"
+    end
+    
+    def self.hi(name)
+      "hi #{name}!"
+    end
+  end
+  
+  it "should async send class methods" do
+    Greeter.async_send(:hi, 'Jeannette')
+    @q.reserve.perform.should eql(Greeter.send(:hi, 'Jeannette'))
+  end
+  
+  it "should async send instance methods" do
+    Greeter.new("brad").async_send(:hi, 'stunning')
+    @q.reserve.perform.should eql(Greeter.new("brad").send(:hi, 'stunning'))
+  end
+  
+end
+
+describe AsyncSender::ActiveRecord do
+  
+  ActiveRecord::Base.establish_connection({
+    :adapter => 'sqlite3',
+    :database => ':memory:'
+  })
+  
+  ActiveRecord::Schema.define do
+    create_table "users", :force => true do |t|
+      t.column "first_name",  :text
+      t.column "last_name",  :text
+      t.column "email", :text
+    end
+  end
+  
+  class User < ActiveRecord::Base
+    include Quebert::AsyncSender::ActiveRecord
+    
+    def name
+      "#{first_name} #{last_name}"
+    end
+    
+    def self.email(address)
+      address
+    end
+  end
+  
+  before(:all) do
+    @q = Backend::InProcess.new
+    Quebert::AsyncSender::ActiveRecord::RecordJob.backend = @q
+    Quebert::AsyncSender::Object::ObjectJob.backend = @q
+    
+    @user = User.create!(:first_name => 'Brad', :last_name => 'Gessler', :email => 'brad@bradgessler.com')
+  end
+  
+  it "should async_send instance method" do
+    User.first.async_send(:name)
+    @q.reserve.perform.should eql(User.first.name)
+  end
+  
+  it "should async_send class method" do
+    email = "brad@bradgessler.com"
+    User.async_send(:email, email)
+    @q.reserve.perform.should eql(email)
+  end
+end