girl_friday 0.9.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use rbx
+export RBXOPT=-Xrbc.db=~/.rbxdb

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in girl_friday.gemspec
+gemspec
+
+# Needed for testing only!
+gem 'minitest'
+gem 'redis'

data/History.md

@@ -0,0 +1,9 @@
+Changes
+================
+
+
+
+0.9.0
+---------
+
+* Initial release

data/README.md

@@ -0,0 +1,67 @@
+girl_friday
+====================
+
+Have a task you want to get done sometime soon but don't want to do it yourself?  Give it to girl_friday!  From wikipedia:
+
+> The term Man Friday has become an idiom, still in mainstream usage, to describe an especially faithful servant or
+> one's best servant or right-hand man. The female equivalent is Girl Friday. The title of the movie His Girl Friday
+> alludes to it and may have popularized it.
+
+girl_friday is a Ruby library for performing asynchronous tasks.  Often times you don't want to block a web response by performing some task, like sending an email, so you can just use this gem to perform it in the background.  It works with any Ruby application, including Rails 3 applications.
+
+
+Installation
+------------------
+
+We recommend using [JRuby 1.6+](http://jruby.org) or [Rubinius 2.0+](http://rubini.us) with girl_friday.  Both are excellent options for executing Ruby these days.
+
+    gem install girl_friday
+
+girl_friday does not support Ruby 1.8 (MRI) because of its poor threading support.  Ruby 1.9 will work reasonably well if you use gems that release the GIL for network I/O (mysql2 is a good example of this, do **not** use the original mysql gem).
+
+
+Usage
+--------------------
+
+Put girl_friday in your Gemfile:
+
+    gem 'girl_friday'
+
+In your Rails app, create a `config/initializers/girl_friday.rb` which defines your queues:
+
+    EMAIL_QUEUE = GirlFriday::WorkQueue.new(:user_email, :size => 3) do |msg|
+      UserMailer.registration_email(msg).deliver
+    end
+    IMAGE_QUEUE = GirlFriday::WorkQueue.new(:image_crawler, :size => 7) do |msg|
+      ImageCrawler.process(msg)
+    end
+
+:size is the number of workers to spin up and defaults to 5.  Keep in mind, ActiveRecord defaults to a connection pool size of 5 so if your workers are accessing the database you'll want to ensure that the connection pool is large enough by modifying `config/database.yml`.
+
+In your controller action or model, you can call `#push(msg)`
+
+    EMAIL_QUEUE.push(:email => @user.email, :name => @user.name)
+
+The msg parameter to push is just a Hash whose contents are completely up to you.
+
+Your message processing block should **not** access any instance data or variables outside of the block.  That's shared mutable state and dangerous to touch!  I also strongly recommend your queue processor block be **VERY** short, ideally just a method call or two.  You can unit test those methods easily but not the processor block itself.
+
+
+More Detail
+--------------------
+
+Please see the [girl_friday wiki](https://github.com/mperham/girl_friday/wiki) for more detail and advanced options and tuning.  You'll find details on queue persistence with Redis, implementing clean shutdown, querying runtime metrics and SO MUCH MORE!
+
+
+Thanks
+--------------------
+
+[Carbon Five](http://carbonfive.com), I write and maintain girl_friday on their clock.
+
+This gem contains a copy of the Rubinius Actor API, modified to work on any Ruby VM.  Thanks to Evan Phoenix, MenTaLguY and the Rubinius project for permission to use and distribute this code.
+
+
+Author
+--------------------
+
+Mike Perham, [@mperham](https://twitter.com/mperham), [mikeperham.com](http://mikeperham.com)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.warning = true
+  test.pattern = 'test/**/test_*.rb'
+end
+
+task :default => :test

data/TODO.md

@@ -0,0 +1,5 @@
+TODO
+===============
+
+ - web admin UI to surface status() metrics
+ - nicer project homepage

data/girl_friday.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require "./lib/girl_friday/version"
+
+Gem::Specification.new do |s|
+  s.name        = "girl_friday"
+  s.version     = GirlFriday::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mike Perham"]
+  s.email       = ["mperham@gmail.com"]
+  s.homepage    = "http://github.com/mperham/girl_friday"
+  s.summary     = s.description = %q{Background processing, simplified}
+
+  s.rubyforge_project = "girl_friday"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/girl_friday/actor.rb

@@ -0,0 +1,463 @@
+# actor.rb - implementation of the actor model
+#
+# Copyright 2007-2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   thi slist of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentatio
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Evan Phoenix nor the names of its contributors 
+#   may be used to endorse or promote products derived from this software 
+#   without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'thread' # for Queue
+
+class Actor
+  class DeadActorError < RuntimeError
+    attr_reader :actor
+    attr_reader :reason
+    def initialize(actor, reason)
+      super(reason)
+      @actor = actor
+      @reason = reason
+    end
+  end
+
+  ANY = Object.new
+  def ANY.===(other)
+    true
+  end
+
+  class << self
+    alias_method :private_new, :new
+    private :private_new
+
+    @@registered_lock = Queue.new
+    @@registered = {}
+    @@registered_lock << nil
+  
+    def current
+      Thread.current[:__current_actor__] ||= private_new
+    end
+
+    # Spawn a new Actor that will run in its own thread
+    def spawn(*args, &block)
+      raise ArgumentError, "no block given" unless block
+      spawned = Queue.new
+      Thread.new do
+        private_new do |actor|
+          Thread.current[:__current_actor__] = actor
+          spawned << actor
+          block.call(*args)
+        end
+      end
+      spawned.pop
+    end
+    alias_method :new, :spawn
+
+    # Atomically spawn an actor and link it to the current actor
+    def spawn_link(*args, &block)
+      current = self.current
+      link_complete = Queue.new
+      spawn do
+        begin
+          Actor.link(current)
+        ensure
+          link_complete << Actor.current
+        end
+        block.call(*args)
+      end
+      link_complete.pop
+    end
+
+    # Polls for exit notifications
+    def check_for_interrupt
+      current._check_for_interrupt
+      self
+    end
+
+    # Waits until a matching message is received in the current actor's
+    # mailbox, and executes the appropriate action.  May be interrupted by
+    # exit notifications.
+    def receive #:yields: filter
+      filter = Filter.new
+      if block_given?
+        yield filter
+      else
+        filter.when(ANY) { |m| m }
+      end
+      current._receive(filter)
+    end
+
+    # Send a "fake" exit notification to another actor, as if the current
+    # actor had exited with +reason+
+    def send_exit(recipient, reason)
+      recipient.notify_exited(current, reason)
+      self
+    end
+    
+    # Link the current Actor to another one.
+    def link(actor)
+      current = self.current
+      current.notify_link actor
+      actor.notify_link current
+      self
+    end
+    
+    # Unlink the current Actor from another one
+    def unlink(actor)
+      current = self.current
+      current.notify_unlink actor
+      actor.notify_unlink current
+      self
+    end
+
+    # Actors trapping exit do not die when an error occurs in an Actor they
+    # are linked to.  Instead the exit message is sent to their regular
+    # mailbox in the form [:exit, actor, reason].  This allows certain
+    # Actors to supervise sets of others and restart them in the event
+    # of an error.  Setting the trap flag may be interrupted by pending
+    # exit notifications.
+    #
+    def trap_exit=(value)
+      current._trap_exit = value
+      self
+    end
+
+    # Is the Actor trapping exit?
+    def trap_exit
+      current._trap_exit
+    end
+    alias_method :trap_exit?, :trap_exit
+
+    # Lookup a locally named service
+    def lookup(name)
+      raise ArgumentError, "name must be a symbol" unless Symbol === name
+      @@registered_lock.pop
+      begin
+        @@registered[name]
+      ensure
+        @@registered_lock << nil
+      end
+    end
+    alias_method :[], :lookup
+
+    # Register an Actor locally as a named service
+    def register(name, actor)
+      raise ArgumentError, "name must be a symbol" unless Symbol === name
+      unless actor.nil? or actor.is_a?(Actor)
+        raise ArgumentError, "only actors may be registered"
+      end
+
+      @@registered_lock.pop
+      begin
+        if actor.nil?
+          @@registered.delete(name)
+        else
+          @@registered[name] = actor
+        end
+      ensure
+        @@registered_lock << nil
+      end
+    end
+    alias_method :[]=, :register
+
+    def _unregister(actor) #:nodoc:
+      @@registered_lock.pop
+      begin
+        @@registered.delete_if { |n, a| actor.equal? a }
+      ensure
+        @@registered_lock << nil
+      end
+    end
+  end
+
+  def initialize
+    @lock = Queue.new
+
+    @filter = nil
+    @ready = Queue.new
+    @action = nil
+    @message = nil
+
+    @mailbox = []
+    @interrupts = []
+    @links = []
+    @alive = true
+    @exit_reason = nil
+    @trap_exit = false
+    @thread = Thread.current
+
+    @lock << nil
+
+    if block_given?
+      watchdog { yield self }
+    else
+      Thread.new { watchdog { @thread.join } }
+    end
+  end
+
+  def send(message)
+    @lock.pop
+    begin
+      return self unless @alive
+      if @filter
+        @action = @filter.action_for(message)
+        if @action
+          @filter = nil
+          @message = message
+          @ready << nil
+        else
+          @mailbox << message
+        end
+      else
+        @mailbox << message
+      end
+    ensure
+      @lock << nil
+    end
+    self
+  end
+  alias_method :<<, :send
+
+  def _check_for_interrupt #:nodoc:
+    check_thread
+    @lock.pop
+    begin
+      raise @interrupts.shift unless @interrupts.empty?
+    ensure
+      @lock << nil
+    end
+  end
+
+  def _receive(filter) #:nodoc:
+    check_thread
+
+    action = nil
+    message = nil
+    timed_out = false
+
+    @lock.pop
+    begin
+      raise @interrupts.shift unless @interrupts.empty?
+
+      for i in 0...(@mailbox.size)
+        message = @mailbox[i]
+        action = filter.action_for(message)
+        if action
+          @mailbox.delete_at(i)
+          break
+        end
+      end
+
+      unless action
+        @filter = filter
+        @lock << nil
+        begin
+          if filter.timeout?
+            timed_out = @ready.receive_timeout(filter.timeout) == false # TODO Broken!
+          else
+            @ready.pop
+          end
+        ensure
+          @lock.pop
+        end
+
+        if !timed_out and @interrupts.empty?
+          action = @action
+          message = @message
+        else
+          @mailbox << @message if @action
+        end
+
+        @action = nil
+        @message = nil
+
+        raise @interrupts.shift unless @interrupts.empty?
+      end
+    ensure
+      @lock << nil
+    end
+
+    if timed_out
+      filter.timeout_action.call
+    else
+      action.call message
+    end
+  end
+ 
+  # Notify this actor that it's now linked to the given one; this is not
+  # intended to be used directly except by actor implementations.  Most
+  # users will want to use Actor.link instead.
+  #
+  def notify_link(actor)
+    @lock.pop
+    alive = nil
+    exit_reason = nil
+    begin
+      alive = @alive
+      exit_reason = @exit_reason
+      @links << actor if alive and not @links.include? actor
+    ensure
+      @lock << nil
+    end
+    actor.notify_exited(self, exit_reason) unless alive
+    self
+  end
+  
+  # Notify this actor that it's now unlinked from the given one; this is
+  # not intended to be used directly except by actor implementations.  Most
+  # users will want to use Actor.unlink instead.
+  #
+  def notify_unlink(actor)
+    @lock.pop
+    begin
+      return self unless @alive
+      @links.delete(actor)
+    ensure
+      @lock << nil
+    end
+    self
+  end
+  
+  # Notify this actor that one of the Actors it's linked to has exited;
+  # this is not intended to be used directly except by actor implementations.
+  # Most users will want to use Actor.send_exit instead.
+  #
+  def notify_exited(actor, reason)
+    exit_message = nil
+    @lock.pop
+    begin
+      return self unless @alive
+      @links.delete(actor)
+      if @trap_exit
+        exit_message = DeadActorError.new(actor, reason)
+      elsif reason
+        @interrupts << DeadActorError.new(actor, reason)
+        if @filter
+          @filter = nil
+          @ready << nil
+        end
+      end
+    ensure
+      @lock << nil
+    end
+    send exit_message if exit_message
+    self
+  end
+
+  def watchdog
+    reason = nil
+    begin
+      yield
+    rescue Exception => reason
+    ensure
+      links = nil
+      Actor._unregister(self)
+      @lock.pop
+      begin
+        @alive = false
+        @mailbox = nil
+        @interrupts = nil
+        @exit_reason = reason
+        links = @links
+        @links = nil
+      ensure
+        @lock << nil
+      end
+      links.each do |actor|
+        begin
+          actor.notify_exited(self, reason)
+        rescue Exception
+        end
+      end
+    end
+  end
+  private :watchdog
+
+  def check_thread
+    unless Thread.current == @thread
+      raise ThreadError, "illegal cross-actor call"
+    end
+  end
+  private :check_thread
+  
+  def _trap_exit=(value) #:nodoc:
+    check_thread
+    @lock.pop
+    begin
+      raise @interrupts.shift unless @interrupts.empty?
+      @trap_exit = !!value
+    ensure
+      @lock << nil
+    end
+  end
+  
+  def _trap_exit #:nodoc:
+    check_thread
+    @lock.pop
+    begin
+      @trap_exit
+    ensure
+      @lock << nil
+    end
+  end
+end
+
+
+class Actor
+class Filter
+  attr_reader :timeout
+  attr_reader :timeout_action
+
+  def initialize
+    @pairs = []
+    @timeout = nil
+    @timeout_action = nil
+  end
+
+  def timeout?
+    not @timeout.nil?
+  end
+
+  def when(pattern, &action)
+    raise ArgumentError, "no block given" unless action
+    @pairs.push [pattern, action]
+    self
+  end
+
+  def after(seconds, &action)
+    raise ArgumentError, "no block given" unless action
+
+    seconds = seconds.to_f
+    if !@timeout or seconds < @timeout
+      @timeout = seconds
+      @timeout_action = action
+    end
+    self
+  end
+
+  def action_for(value)
+    pair = @pairs.find { |pattern, action| pattern === value }
+    pair ? pair.last : nil
+  end
+end
+end

data/lib/girl_friday/error_handler.rb

@@ -0,0 +1,22 @@
+module GirlFriday
+  class ErrorHandler
+    def handle(ex)
+      $stderr.puts(ex)
+      $stderr.puts(ex.backtrace.join("\n"))
+    end
+    
+    def self.default
+      defined?(HoptoadNotifier) ? Hoptoad : self
+    end
+  end
+end
+
+module GirlFriday
+  class ErrorHandler
+    class Hoptoad
+      def handle(ex)
+        HoptoadNotifier.notify(ex)
+      end
+    end
+  end
+end

data/lib/girl_friday/monkey_patches.rb

@@ -0,0 +1,31 @@
+if RUBY_ENGINE == 'rbx' && (Rubinius::VERSION < '1.2.4' || Rubinius::VERSION == '1.2.4dev')
+  puts "Loading rubinius actor monkeypatches" if $testing
+  class Actor
+
+    # Monkeypatch so this works with Rubinius 1.2.3 (latest).
+    # 1.2.4 should have the necessary fix included.
+    def notify_exited(actor, reason)
+      exit_message = nil
+      @lock.receive
+      begin
+        return self unless @alive
+        @links.delete(actor)
+        if @trap_exit
+          exit_message = DeadActorError.new(actor, reason)
+        elsif reason
+          @interrupts << DeadActorError.new(actor, reason)
+          if @filter
+            @filter = nil
+            @ready << nil
+          end
+        end
+      ensure
+        @lock << nil
+      end
+      send exit_message if exit_message
+      self
+    end
+  
+  end
+
+end

data/lib/girl_friday/persistence.rb

@@ -0,0 +1,52 @@
+module GirlFriday
+  module Store
+
+    class InMemory
+      def initialize(name, options)
+        @backlog = []
+      end
+
+      def push(work)
+        @backlog << work
+      end
+      alias_method :<<, :push
+      
+      def pop
+        @backlog.pop
+      end
+      
+      def size
+        @backlog.size
+      end
+    end
+    
+    class Redis
+      def initialize(name, options)
+        @opts = options
+        @key = "girl_friday-#{name}"
+      end
+
+      def push(work)
+        val = Marshal.dump(work)
+        redis.rpush(@key, val)
+      end
+      alias_method :<<, :push
+
+      def pop
+        val = redis.lpop(@key)
+        Marshal.load(val) if val
+      end
+
+      def size
+        redis.llen(@key)
+      end
+
+      private
+
+      def redis
+        @redis ||= ::Redis.new(*@opts)
+      end
+    end
+  end
+end
+    

data/lib/girl_friday/version.rb

@@ -0,0 +1,3 @@
+module GirlFriday
+  VERSION = "0.9.0"
+end

data/lib/girl_friday/work_queue.rb

@@ -0,0 +1,145 @@
+module GirlFriday
+
+  class WorkQueue
+    Ready = Struct.new(:this)
+    Work = Struct.new(:msg, :callback)
+    Shutdown = Struct.new(:callback)
+
+    attr_reader :name
+    def initialize(name, options={}, &block)
+      @name = name
+      @size = options[:size] || 5
+      @processor = block
+      @error_handler = (options[:error_handler] || ErrorHandler.default).new
+
+      @shutdown = false
+      @ready_workers = []
+      @busy_workers = []
+      @created_at = Time.now.to_i
+      @total_processed = @total_errors = @total_queued = 0
+      @persister = (options[:store] || Store::InMemory).new(name, (options[:store_config] || []))
+      start
+    end
+  
+    def push(work, &block)
+      @supervisor << Work[work, block]
+    end
+    alias_method :<<, :push
+
+    def status
+      { @name => {
+          :pid => $$,
+          :pool_size => @size,
+          :ready => @ready_workers.size,
+          :busy => @busy_workers.size,
+          :backlog => @persister.size,
+          :total_queued => @total_queued,
+          :total_processed => @total_processed,
+          :total_errors => @total_errors,
+          :uptime => Time.now.to_i - @created_at,
+          :created_at => @created_at,
+        }
+      }
+    end
+
+    def shutdown
+      # Runtime state should never be modified by caller thread,
+      # only the Supervisor thread.
+      @supervisor << Shutdown[block_given? ? Proc.new : nil]
+    end
+
+    private
+
+    def on_ready(who)
+      @total_processed += 1
+      if !@shutdown && work = @persister.pop
+        who.this << work
+        drain(@ready_workers, @persister)
+      else
+        @busy_workers.delete(who.this)
+        @ready_workers << who.this
+        shutdown_complete if @shutdown && @busy_workers.size == 0
+      end
+    end
+
+    def shutdown_complete
+      begin
+        @when_shutdown.call(self) if @when_shutdown
+      rescue Exception => ex
+        @error_handler.handle(ex)
+      end
+    end
+
+    def on_work(work)
+      @total_queued += 1
+      if !@shutdown && worker = @ready_workers.pop
+        @busy_workers << worker
+        worker << work
+        drain(@ready_workers, @persister)
+      else
+        @persister << work
+      end
+    end
+
+    def start
+      @supervisor = Actor.spawn do
+        supervisor = Actor.current
+        work_loop = Proc.new do
+          loop do
+            work = Actor.receive
+            result = @processor.call(work.msg)
+            work.callback.call(result) if work.callback
+            supervisor << Ready[Actor.current]
+          end
+        end
+
+        Actor.trap_exit = true
+        @size.times do |x|
+          # start N workers
+          @ready_workers << Actor.spawn_link(&work_loop)
+        end
+
+        begin
+          loop do
+            Actor.receive do |f|
+              f.when(Ready) do |who|
+                on_ready(who)
+              end
+              f.when(Work) do |work|
+                on_work(work)
+              end
+              f.when(Shutdown) do |stop|
+                @shutdown = true
+                @when_shutdown = stop.callback
+                shutdown_complete if @shutdown && @busy_workers.size == 0
+              end
+              f.when(Actor::DeadActorError) do |exit|
+                # TODO Provide current message contents as error context
+                @total_errors += 1
+                @busy_workers.delete(exit.actor)
+                @ready_workers << Actor.spawn_link(&work_loop)
+                @error_handler.handle(exit.reason)
+              end
+            end
+          end
+
+        rescue Exception => ex
+          $stderr.print "Fatal error in girl_friday: supervisor for #{name} died.\n"
+          $stderr.print("#{ex}\n")
+          $stderr.print("#{ex.backtrace.join("\n")}\n")
+        end
+      end
+    end
+
+    def drain(ready, work)
+      # give as much work to as many ready workers as possible
+      todo = ready.size < work.size ? ready.size : work.size
+      todo.times do
+        worker = ready.pop
+        @busy_workers << worker
+        worker << work.pop
+      end
+    end
+
+  end
+end

data/lib/girl_friday.rb

@@ -0,0 +1,52 @@
+require 'thread'
+begin
+  # Rubinius
+  require 'actor'
+  require 'girl_friday/monkey_patches'
+rescue LoadError
+  # Others
+  require 'girl_friday/actor'
+end
+
+require 'girl_friday/version'
+require 'girl_friday/work_queue'
+require 'girl_friday/error_handler'
+require 'girl_friday/persistence'
+
+module GirlFriday
+
+  def self.status
+    ObjectSpace.each_object(WorkQueue).inject({}) { |memo, queue| memo.merge(queue.status) }
+  end
+
+  ##
+  # Notify girl_friday to shutdown ASAP.  Workers will not pick up any
+  # new work; any new work pushed onto the queues will be pushed onto the
+  # backlog (and persisted).  This method will block until all queues are
+  # quiet or the timeout has passed.
+  #
+  # Note that shutdown! just works with existing queues.  If you create a
+  # new queue, it will act as normal.
+  def self.shutdown!(timeout=30)
+    queues = []
+    ObjectSpace.each_object(WorkQueue).each { |q| queues << q }
+    count = queues.size
+    m = Mutex.new
+    var = ConditionVariable.new
+
+    queues.each do |q|
+      q.shutdown do |queue|
+        m.synchronize do
+          count -= 1
+          var.signal if count == 0
+        end
+      end
+    end
+
+    m.synchronize do
+      var.wait(m, timeout)
+    end
+    count
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,24 @@
+$testing = true
+
+# require 'simplecov'
+# SimpleCov.start do
+#   add_filter "/actor.rb"
+# end
+
+# rbx is 1.8-mode for another month...
+require 'rubygems'
+require 'minitest/autorun'
+require 'timed_queue'
+require 'girl_friday'
+
+puts RUBY_DESCRIPTION
+
+class MiniTest::Unit::TestCase
+
+  def async_test(time=0.5)
+    q = TimedQueue.new
+    yield Proc.new { q << nil }
+    q.timed_pop(time)
+  end
+
+end

data/test/test_girl_friday.rb

@@ -0,0 +1,140 @@
+require 'helper'
+
+class TestGirlFriday < MiniTest::Unit::TestCase
+
+  class TestErrorHandler
+    include MiniTest::Assertions
+  end
+
+  def test_should_process_messages
+    async_test do |cb|
+      queue = GirlFriday::WorkQueue.new('test') do |msg|
+        assert_equal 'foo', msg[:text]
+        cb.call
+      end
+      queue.push(:text => 'foo')
+    end
+  end
+
+  def test_should_handle_worker_error
+    async_test do |cb|
+      TestErrorHandler.send(:define_method, :handle) do |ex|
+        assert_equal 'oops', ex.message
+        assert_equal 'RuntimeError', ex.class.name
+        cb.call
+      end
+
+      queue = GirlFriday::WorkQueue.new('test', :error_handler => TestErrorHandler) do |msg|
+        raise 'oops'
+      end
+      queue.push(:text => 'foo')
+    end
+  end
+
+  def test_should_call_callback_when_complete
+    async_test do |cb|
+      queue = GirlFriday::WorkQueue.new('test', :size => 1) do |msg|
+        assert_equal 'foo', msg[:text]
+        'camel'
+      end
+      queue.push(:text => 'foo') do |result|
+        assert_equal 'camel', result
+        cb.call
+      end
+    end
+  end
+
+  def test_should_provide_status
+    mutex = Mutex.new
+    total = 200
+    count = 0
+    incr = Proc.new do
+      mutex.synchronize do
+        count += 1
+      end
+    end
+
+    async_test do |cb|
+      count = 0
+      queue = GirlFriday::WorkQueue.new('image_crawler', :size => 3) do |msg|
+        incr.call
+        cb.call if count == total
+      end
+      total.times do |idx|
+        queue.push(:text => 'foo')
+      end
+
+      sleep 0.01
+      actual = GirlFriday.status
+      refute_nil actual
+      refute_nil actual['image_crawler']
+      metrics = actual['image_crawler']
+      assert_equal total, metrics[:total_queued]
+      assert_equal 3, metrics[:pool_size]
+      assert_equal 3, metrics[:busy]
+      assert_equal 0, metrics[:ready]
+      assert(metrics[:backlog] > 0)
+      assert(metrics[:total_processed] > 0)
+    end
+  end
+
+  def test_should_persist_with_redis
+    begin
+      require 'redis'
+      redis = Redis.new
+      redis.flushdb
+    rescue LoadError
+      return puts "Skipping redis test, 'redis' gem not found: #{$!.message}"
+    rescue Errno::ECONNREFUSED
+      return puts 'Skipping redis test, not running locally'
+    end
+
+    mutex = Mutex.new
+    total = 100
+    count = 0
+    incr = Proc.new do
+      mutex.synchronize do
+        count += 1
+      end
+    end
+
+    async_test do |cb|
+      queue = GirlFriday::WorkQueue.new('test', :size => 2, :store => GirlFriday::Store::Redis) do |msg|
+        incr.call
+        cb.call if count == total
+      end
+      total.times do
+        queue.push(:text => 'foo')
+      end
+    end
+  end
+
+  def test_should_allow_graceful_shutdown
+    mutex = Mutex.new
+    total = 100
+    count = 0
+    incr = Proc.new do
+      mutex.synchronize do
+        count += 1
+      end
+    end
+
+    async_test do |cb|
+      queue = GirlFriday::WorkQueue.new('shutdown', :size => 2) do |msg|
+        incr.call
+        cb.call if count == total
+      end
+      total.times do
+        queue.push(:text => 'foo')
+      end
+
+      GirlFriday.shutdown!
+      s = queue.status
+      assert_equal 0, s['shutdown'][:busy]
+      assert_equal 2, s['shutdown'][:ready]
+      assert(s['shutdown'][:backlog] > 0)
+      cb.call
+    end
+  end
+
+end

data/test/timed_queue.rb

@@ -0,0 +1,48 @@
+require 'thread'
+require 'timeout'
+
+class TimedQueue
+  def initialize
+    @que = []
+    @waiting = []
+    @mutex = Mutex.new
+    @resource = ConditionVariable.new
+  end
+
+  def push(obj)
+    @mutex.synchronize do
+      @que.push obj
+      @resource.signal
+    end
+  end
+  alias << push
+
+  def timed_pop(timeout=0.5)
+    while true
+      @mutex.synchronize do
+        @waiting.delete(Thread.current)
+        if @que.empty?
+          @waiting.push Thread.current
+          @resource.wait(@mutex, timeout)
+          raise TimeoutError if @que.empty?
+        else
+          retval = @que.shift
+          @resource.signal
+          return retval
+        end
+      end
+    end
+  end
+
+  def empty?
+    @que.empty?
+  end
+
+  def clear
+    @que.clear
+  end
+
+  def length
+    @que.length
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: girl_friday
+version: !ruby/object:Gem::Version 
+  hash: 59
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Mike Perham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Background processing, simplified
+email: 
+- mperham@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- History.md
+- README.md
+- Rakefile
+- TODO.md
+- girl_friday.gemspec
+- lib/girl_friday.rb
+- lib/girl_friday/actor.rb
+- lib/girl_friday/error_handler.rb
+- lib/girl_friday/monkey_patches.rb
+- lib/girl_friday/persistence.rb
+- lib/girl_friday/version.rb
+- lib/girl_friday/work_queue.rb
+- test/helper.rb
+- test/test_girl_friday.rb
+- test/timed_queue.rb
+has_rdoc: true
+homepage: http://github.com/mperham/girl_friday
+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: girl_friday
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Background processing, simplified
+test_files: 
+- test/helper.rb
+- test/test_girl_friday.rb
+- test/timed_queue.rb