beanstalker 0.0.1 → 0.1.1

data/README

@@ -1,27 +1,6 @@
-This is Async Observer -- a Rails plugin that provides deep integration with
-Beanstalk.
+This is Beanstalker -- a Rails gem that provides deep integration with
+Beanstalk. (forked from async_observer)
 
-For more information, see http://async-observer.rubyforge.org/.
+This version is rewritten using daemonizer.
 
-For more information on Beanstalk, see its home page at
-http://xph.us/software/beanstalkd/.
-
-
-Worker Options:
--d                                : daemonize
---pid [path to pidfile]           : drop a pid file to a path
--e [test,production,development]  : set the rails environment
-
-Example Usage:
-
-start 3 workers
-  ./vendor/plugins/async_observer/bin/worker -d --pid log/worker1.pid -e production
-  ./vendor/plugins/async_observer/bin/worker -d --pid log/worker2.pid -e production
-  ./vendor/plugins/async_observer/bin/worker -d --pid log/worker3.pid -e production
-
-kill one
-  kill -s INT `cat log/worker1.pid`
-
-Remember kill a worker will cause it to go into a shutdown phase.
-Run the above again to kill immediately, but remember all jobs in
-the workers queue is lost at that point...
+Documentation coming soon...

data/Rakefile

@@ -6,12 +6,14 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "beanstalker"
     gem.summary = %Q{Beanstalker provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer}
-    gem.description = %Q{Beanstalker provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer}
+    gem.description = %Q{Beanstalker is a tool for executing long tasks in background in our rails application.}
     gem.email = "glebpom@gmail.com"
     gem.homepage = "http://github.com/glebpom/beanstalker"
     gem.authors = ["Gleb Pomykalov"]
 #    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    gem.add_dependency "daemonizer"
+    gem.add_dependency "daemonizer", "~>0.2.0"
+    gem.add_dependency "beanstalk-client"
+    gem.add_dependency "rails", ">= 2.2.0"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.1

data/glebpom-async_observer.gemspec

@@ -0,0 +1,56 @@
+# 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{glebpom-async_observer}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gleb Pomykalov"]
+  s.date = %q{2010-07-14}
+  s.description = %q{async_observer provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer}
+  s.email = %q{glebpom@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "COPYING",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "glebpom-async_observer.gemspec",
+     "init.rb",
+     "lib/async_observer/daemonizer_handler.rb",
+     "lib/async_observer/extend.rb",
+     "lib/async_observer/queue.rb",
+     "lib/async_observer/worker.rb"
+  ]
+  s.homepage = %q{http://github.com/glebpom/async_observer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{async_observer provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer}
+
+  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_runtime_dependency(%q<daemonizer>, ["~> 0.2.0"])
+      s.add_runtime_dependency(%q<beanstalk-client>, [">= 0"])
+      s.add_runtime_dependency(%q<rails>, [">= 2.2.0"])
+    else
+      s.add_dependency(%q<daemonizer>, ["~> 0.2.0"])
+      s.add_dependency(%q<beanstalk-client>, [">= 0"])
+      s.add_dependency(%q<rails>, [">= 2.2.0"])
+    end
+  else
+    s.add_dependency(%q<daemonizer>, ["~> 0.2.0"])
+    s.add_dependency(%q<beanstalk-client>, [">= 0"])
+    s.add_dependency(%q<rails>, [">= 2.2.0"])
+  end
+end
+

data/lib/async_observer/daemonizer_handler.rb

@@ -0,0 +1,21 @@
+module AsyncObserver
+  class DaemonizerHandler < Daemonizer::Handler
+    def prepare(block)
+      logger.info "Loading Rails"
+      require File.join(Daemonizer.root, '/config/environment')
+      require 'async_observer/worker'
+      logger.info "Rails loaded"
+      super
+    end
+    
+    def start
+      logger.info "Starting cycle"
+      Worker.new(binding, 
+                :tube => option(:tube), 
+                :servers => option(:servers),
+                :worker_id => worker_id, 
+                :workers_count => workers_count).run
+      logger.info "Ending cycle"
+    end
+  end
+end

data/lib/async_observer/extend.rb

@@ -29,12 +29,39 @@ CLASSES_TO_EXTEND = [
 ]
 
 module AsyncObserver::Extensions
+  def self.included(receiver)
+    @@methods_async_options = {}
+    receiver.extend(ClassMethods)
+  end
+    
+  module ClassMethods
+    def async_method(method, options = {})
+      methods_async_options = class_variable_get(:@@methods_async_options)
+      if options
+        class_variable_set(:@@methods_async_options, methods_async_options.merge(method.to_sym => options))
+      end
+    end
+  end
+  
+  def interpolate_async_options(options, object)
+    result = {}
+    options.each do |k,v|
+      result[k] = if v.is_a?(Proc)
+        v.call(object)
+      else
+        v
+      end
+    end
+    result
+  end
+  
   def async_send(selector, *args)
-    async_send_opts(selector, {}, *args)
+    async_send_opts(selector, @@methods_async_options[selector.to_sym] || {}, *args)
   end
 
   def async_send_opts(selector, opts, *args)
-    AsyncObserver::Queue.put_call!(self, selector, opts, args)
+    interpolated_options = interpolate_async_options(opts, self)
+    AsyncObserver::Queue.put_call!(self, selector, interpolated_options, args)
   end
 end
 
@@ -73,7 +100,7 @@ class Range
       fanout_opts = opts.merge(:fuzz => opts.fetch(:fanout_fuzz,
                                                    DEFAULT_FANOUT_FUZZ))
       fanout_opts[:pri] = opts[:fanout_pri] || opts[:pri]
-      fanout_opts = fanout_opts.reject_hash{|k,v| nil.equal?(v)}
+      fanout_opts = fanout_opts.reject{ |k,v| v.nil? }
       split_to(fanout_degree) do |subrange|
         subrange.async_send_opts(:async_each_opts, fanout_opts, rcv, selector,
                                  opts, *extra)

data/lib/async_observer/queue.rb

@@ -29,7 +29,7 @@ class << AsyncObserver::Queue
   DEFAULT_TTR = 120
   DEFAULT_TUBE = 'default'
 
-  attr_accessor :queue, :app_version, :after_put
+  attr_accessor :queue, :after_put
 
   # This is a fake worker instance for running jobs synchronously.
   def sync_worker()
@@ -48,7 +48,7 @@ class << AsyncObserver::Queue
 
   def put!(obj, pri=DEFAULT_PRI, delay=DEFAULT_DELAY, ttr=DEFAULT_TTR,
            tube=DEFAULT_TUBE)
-    return sync_run(obj) if (:direct.equal?(pri) or !queue)
+    return sync_run(obj) if pri == :direct || !queue
     queue.connect()
     queue.use(tube)
     info = [queue.yput(obj, pri, delay, ttr), queue.last_server]
@@ -64,14 +64,21 @@ class << AsyncObserver::Queue
     fuzz = opts.fetch(:fuzz, DEFAULT_FUZZ)
     delay = opts.fetch(:delay, DEFAULT_DELAY)
     ttr = opts.fetch(:ttr, DEFAULT_TTR)
-    tube = opts.fetch(:tube, (app_version or DEFAULT_TUBE))
+    tube = opts.fetch(:tube, DEFAULT_TUBE)
     worker_opts = opts.reject{|k,v| SUBMIT_OPTS.include?(k)}
-
-    pri = pri + rand(fuzz + 1) if !:direct.equal?(pri)
-
-    code = gen(obj, sel, args)
-    RAILS_DEFAULT_LOGGER.info("put #{pri} #{code}")
-    put!(pkg(code, worker_opts), pri, delay, ttr, tube)
+    interpolator = opts.fetch(:interpolator, nil)
+
+    pri = pri + rand(fuzz + 1) if pri != :direct
+
+    if interpolator
+      code = packed = interpolator
+    else 
+      code = gen(obj, sel, args)
+      packed = pkg(code, worker_opts)
+    end
+    
+    RAILS_DEFAULT_LOGGER.info("put #{pri} #{code} to #{tube}")
+    put!(packed, pri, delay, ttr, tube)
   end
 
   def pkg(code, opts)

data/lib/async_observer/worker.rb

@@ -15,20 +15,11 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-
-begin
-  require 'mysql'
-rescue LoadError
-  # Ignore case where we don't have mysql
-end
 require 'async_observer/queue'
-require 'async_observer/util'
 
 module AsyncObserver; end
 
 class AsyncObserver::Worker
-  extend AsyncObserver::Util
-  include AsyncObserver::Util
 
   SLEEP_TIME = 60 if !defined?(SLEEP_TIME) # rails loads this file twice
 
@@ -55,58 +46,50 @@ class AsyncObserver::Worker
     end
 
     def run_before_reserve
-      before_reserves.each {|b| b.call()}
+      before_reserves.each {|b| b.call}
     end
   end
+  
+  def logger
+    $logger or RAILS_DEFAULT_LOGGER
+  end
 
-  def initialize(top_binding)
+  def initialize(top_binding, options = {})
     @top_binding = top_binding
     @stop = false
+    @options = options
+    if @options && @options[:servers]
+      AsyncObserver::Queue.queue = Beanstalk::Pool.new(@options[:servers])
+    end
   end
 
-  def main_loop()
+  def main_loop
     trap('TERM') { @stop = true }
     loop do
       break if @stop
-      safe_dispatch(get_job())
+      safe_dispatch(get_job)
     end
   end
 
-  def startup()
-    log_bracketed('worker-startup') do
-      appver = AsyncObserver::Queue.app_version
-      RAILS_DEFAULT_LOGGER.info "pid is #{$$}"
-      RAILS_DEFAULT_LOGGER.info "app version is #{appver}"
-      mark_db_socket_close_on_exec()
-      if AsyncObserver::Queue.queue.nil?
-        RAILS_DEFAULT_LOGGER.info 'no queue has been configured'
-        exit(1)
-      end
-      AsyncObserver::Queue.queue.watch(appver) if appver
-    end
+  def startup
+    tube = @options[:tube] || "default"
+    logger.info "Using tube #{tube}"
+    AsyncObserver::Queue.queue.watch(tube)
     flush_logger
   end
 
-  # This prevents us from leaking fds when we exec. Only works for mysql.
-  def mark_db_socket_close_on_exec()
-    ActiveRecord::Base.active_connections.each(&:set_close_on_exec)
-  rescue NoMethodError
-  end
-
-  def shutdown()
-    log_bracketed('worker-shutdown') do
-      do_all_work()
-    end
+  def shutdown
+    do_all_work
   end
 
-  def run()
-    startup()
-    main_loop()
+  def run
+    startup
+    main_loop
   rescue Interrupt
-    shutdown()
+    shutdown
   end
 
-  def q_hint()
+  def q_hint
     @q_hint || AsyncObserver::Queue.queue
   end
 
@@ -114,9 +97,9 @@ class AsyncObserver::Worker
   # if the connection returns a job right away, it probably has more available.
   # But if it takes time, then it's probably empty. So reuse the same
   # connection as long as it stays fast. Otherwise, have no preference.
-  def reserve_and_set_hint()
+  def reserve_and_set_hint
     t1 = Time.now.utc
-    return job = q_hint().reserve()
+    return job = q_hint.reserve
   ensure
     t2 = Time.now.utc
     @q_hint = if brief?(t1, t2) and job then job.conn else nil end
@@ -126,29 +109,27 @@ class AsyncObserver::Worker
     ((t2 - t1) * 100).to_i.abs < 10
   end
 
-  def get_job()
-    log_bracketed('worker-get-job') do
-      loop do
-        begin
-          AsyncObserver::Queue.queue.connect()
-          self.class.run_before_reserve
-          return reserve_and_set_hint()
-        rescue Interrupt => ex
-          raise ex
-        rescue SignalException => ex
-          raise ex
-        rescue Beanstalk::DeadlineSoonError
-          # Do nothing; immediately try again, giving the user a chance to
-          # clean up in the before_reserve hook.
-          RAILS_DEFAULT_LOGGER.info 'Job deadline soon; you should clean up.'
-        rescue Exception => ex
-          @q_hint = nil # in case there's something wrong with this conn
-          RAILS_DEFAULT_LOGGER.info(
-            "#{ex.class}: #{ex}\n" + ex.backtrace.join("\n"))
-          RAILS_DEFAULT_LOGGER.info 'something is wrong. We failed to get a job.'
-          RAILS_DEFAULT_LOGGER.info "sleeping for #{SLEEP_TIME}s..."
-          sleep(SLEEP_TIME)
-        end
+  def get_job
+    loop do
+      begin
+        AsyncObserver::Queue.queue.connect
+        self.class.run_before_reserve
+        return reserve_and_set_hint
+      rescue Interrupt => ex
+        raise ex
+      rescue SignalException => ex
+        raise ex
+      rescue Beanstalk::DeadlineSoonError
+        # Do nothing; immediately try again, giving the user a chance to
+        # clean up in the before_reserve hook.
+        logger.info 'Job deadline soon; you should clean up.'
+      rescue Exception => ex
+        @q_hint = nil # in case there's something wrong with this conn
+        logger.info(
+          "#{ex.class}: #{ex}\n" + ex.backtrace.join("\n"))
+        logger.info 'something is wrong. We failed to get a job.'
+        logger.info "sleeping for #{SLEEP_TIME}s..."
+        sleep(SLEEP_TIME)
       end
     end
   end
@@ -160,30 +141,26 @@ class AsyncObserver::Worker
   end
 
   def safe_dispatch(job)
-    log_bracketed('worker-dispatch') do
-      RAILS_DEFAULT_LOGGER.info "got #{job.inspect}:\n" + job.body
-      log_bracketed('job-stats') do
-        job.stats.each do |k,v|
-          RAILS_DEFAULT_LOGGER.info "#{k}=#{v}"
-        end
-      end
-      begin
-        return dispatch(job)
-      rescue Interrupt => ex
-        begin job.release() rescue :ok end
-        raise ex
-      rescue Exception => ex
-        handle_error(job, ex)
-      ensure
-        flush_logger
-      end
+    logger.info "got #{job.inspect}:\n" + job.body
+    job.stats.each do |k,v|
+      logger.info "#{k}=#{v}"
+    end
+    begin
+      return dispatch(job)
+    rescue Interrupt => ex
+      begin job.release rescue :ok end
+      raise ex
+    rescue Exception => ex
+      handle_error(job, ex)
+    ensure
+      flush_logger
     end
   end
 
   def flush_logger
-    if defined?(RAILS_DEFAULT_LOGGER) &&
-        RAILS_DEFAULT_LOGGER.respond_to?(:flush)
-      RAILS_DEFAULT_LOGGER.flush
+    if defined?(logger) &&
+        logger.respond_to?(:flush)
+      logger.flush
     end
   end
 
@@ -196,25 +173,30 @@ class AsyncObserver::Worker
   end
 
   def self.default_handle_error(job, ex)
-    RAILS_DEFAULT_LOGGER.info "Job failed: #{job.server}/#{job.id}"
-    RAILS_DEFAULT_LOGGER.info("#{ex.class}: #{ex}\n" + ex.backtrace.join("\n"))
-    job.decay()
+    logger.info "Job failed: #{job.server}/#{job.id}"
+    logger.info("#{ex.class}: #{ex}\n" + ex.backtrace.join("\n"))
+    if job.stats['releases'] > 10
+      job.bury
+      logger.info "BURY job due to many releases"
+    else
+      job.decay
+    end
   rescue Beanstalk::UnexpectedResponse
   end
 
   def run_ao_job(job)
-    RAILS_DEFAULT_LOGGER.info 'running as async observer job'
+    logger.info 'running as async observer job'
     f = self.class.before_filter
     f.call(job) if f
     job.delete if job.ybody[:delete_first]
     run_code(job)
-    job.delete() unless job.ybody[:delete_first]
+    job.delete unless job.ybody[:delete_first]
   rescue ActiveRecord::RecordNotFound => ex
     unless job.ybody[:delete_first]
       if job.age > 60
-        job.delete() # it's old; this error is most likely permanent
+        job.delete # it's old; this error is most likely permanent
       else
-        job.decay() # it could be replication delay so retry quietly
+        job.decay # it could be replication delay so retry quietly
       end
     end
   end
@@ -228,36 +210,14 @@ class AsyncObserver::Worker
   end
 
   def run_other(job)
-    RAILS_DEFAULT_LOGGER.info 'trying custom handler'
+    logger.info 'trying custom handler'
     self.class.handle.call(job)
   end
 
-  def do_all_work()
-    RAILS_DEFAULT_LOGGER.info 'finishing all running jobs. interrupt again to kill them.'
+  def do_all_work
+    logger.info 'finishing all running jobs. interrupt again to kill them.'
     f = self.class.finish
-    f.call() if f
+    f.call if f
   end
 end
 
-class ActiveRecord::ConnectionAdapters::MysqlAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
-  def set_close_on_exec()
-    @connection.set_close_on_exec()
-  end
-end
-
-class Mysql
-  def set_close_on_exec()
-    if @net
-      @net.set_close_on_exec()
-    else
-      # we are in the c mysql binding
-      RAILS_DEFAULT_LOGGER.info "Warning: we are using the C mysql binding, can't set close-on-exec"
-    end
-  end
-end
-
-class Mysql::Net
-  def set_close_on_exec()
-    @sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-  end
-end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: beanstalker
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Gleb Pomykalov
@@ -15,13 +15,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-06 00:00:00 +04:00
-default_executable: worker
+date: 2010-07-14 00:00:00 +04:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: daemonizer
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: beanstalk-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -31,11 +47,27 @@ dependencies:
         - 0
         version: "0"
   type: :runtime
-  version_requirements: *id001
-description: Beanstalker provides deep integration with Beanstalk. Fork from http://github.com/kristjan/async_observer
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        - 0
+        version: 2.2.0
+  type: :runtime
+  version_requirements: *id003
+description: Beanstalker is a tool for executing long tasks in background in our rails application.
 email: glebpom@gmail.com
-executables: 
-- worker
+executables: []
+
 extensions: []
 
 extra_rdoc_files: 
@@ -46,12 +78,11 @@ files:
 - README
 - Rakefile
 - VERSION
-- bin/worker
+- glebpom-async_observer.gemspec
 - init.rb
-- lib/async_observer/daemonize.rb
+- lib/async_observer/daemonizer_handler.rb
 - lib/async_observer/extend.rb
 - lib/async_observer/queue.rb
-- lib/async_observer/util.rb
 - lib/async_observer/worker.rb
 has_rdoc: true
 homepage: http://github.com/glebpom/beanstalker

data/bin/worker

@@ -1,70 +0,0 @@
-#!/usr/bin/env ruby
-# async-observer - Rails plugin for asynchronous job execution
-
-# Copyright (C) 2007 Philotic Inc.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-# Use the same pointer (and therefore same buffer) for stdout and stderr.
-$VERBOSE = nil; STDERR = $stderr = STDOUT = $stdout; $VERBOSE = false
-
-require 'time'
-
-def load_rails_and_run
-  # Rails initialization.
-  # We do this here instead of using script/runner because script/runner
-  # breaks __FILE__, which we use below.
-  begin
-    puts "#!load-rails!begin!#{Time.now.utc.xmlschema(6)}"
-    require File.expand_path(File.dirname(__FILE__) + '/../../../../config/boot')
-    puts "RAILS_ROOT=#{RAILS_ROOT.inspect}"
-    require RAILS_ROOT + '/config/environment'
-  ensure
-    puts "#!load-rails!end!#{Time.now.utc.xmlschema(6)}"
-  end
-  require 'async_observer/worker'
-  AsyncObserver::Worker.new(binding).run()
-end
-
-# set environment
-if ARGV.include?('-e') # check rails env
-  env=nil
-  ARGV.each_with_index{|arg,i| env = ARGV[i+1] if arg == '-e' }
-  RAILS_ENV=env unless env.nil?
-end
-
-if ARGV.include?('-d')
-  pidpath = 'log/worker.pid'
-  if ARGV.include?('--pid') # look up the pid path
-    ARGV.each_with_index{|arg,i| pidpath = ARGV[i+1] if arg == '--pid' }
-    STDERR.puts "Missing pid file path!" and exit(1) if pidpath.nil?
-  end
-  unless File.writable?(File.dirname(pidpath))
-    STDERR.puts "#{pidpath} not writable!"
-    exit(1)
-  end
-
-  if File.exist?(pidpath)
-    STDERR.puts "#{pidpath} exits! Make sure the worker isn't still running and try again after rm #{pidpath}"
-    exit(1)
-  end
-
-  require File.dirname(__FILE__) + '/../lib/async_observer/daemonize'
-  AsyncObserver::Daemonize.detach(pidpath) do
-    load_rails_and_run
-  end
-else
-  load_rails_and_run
-end

data/lib/async_observer/daemonize.rb

@@ -1,35 +0,0 @@
-# async-observer - Rails plugin for asynchronous job execution
-# Copyright (C) 2009 Todd A. Fisher.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-module AsyncObserver; end
-
-class AsyncObserver::Daemonize
-  def self.detach(pidfile='log/worker.pid',&block)
-    # daemonize, create a pipe to send status to the parent process, after the child has successfully started or failed
-    fork do
-      Process.setsid
-      fork do
-        Process.setsid
-        File.open(pidfile, 'wb') {|f| f << Process.pid}
-        at_exit { File.unlink(pidfile) }
-        File.umask 0000
-        STDIN.reopen "/dev/null"
-        STDOUT.reopen "/dev/null", "a"
-        STDERR.reopen STDOUT
-        block.call
-      end
-    end
-  end
-end

data/lib/async_observer/util.rb

@@ -1,31 +0,0 @@
-# async-observer - Rails plugin for asynchronous job execution
-
-# Copyright (C) 2007 Philotic Inc.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-require 'open3'
-
-module AsyncObserver; end
-module AsyncObserver::Util
-  def log_bracketed(name)
-    begin
-      RAILS_DEFAULT_LOGGER.info "#!#{name}!begin!#{Time.now.utc.xmlschema(6)}"
-      yield()
-    ensure
-      RAILS_DEFAULT_LOGGER.info "#!#{name}!end!#{Time.now.utc.xmlschema(6)}"
-    end
-  end
-end