background_lite 0.0.1

data/README.rdoc

@@ -0,0 +1,79 @@
+=== BackgroundLite
+
+This Rails plugin supersedes the background plugin, available here:
+
+  http://github.com/imedo/background/tree/master
+
+It allows you to execute methods in a background task with a very intuitive and
+easy syntax. It is as easy as that:
+
+  class MyModel
+    def complex_operation(argument)
+      ...
+    end
+    background_method :complex_operation
+  end
+
+Now, whenever MyModel#complex_operation is called, it will be run in the
+background process.
+
+Refer to the Class#background_method documentation for details.
+
+=== What this plugin is
+
+This plugin is an easy-to-use interface for background processing frameworks.
+Theoretically, you can use it in combination with any of the messaging /
+background processing frameworks out there, though there are not many handlers
+implemented yet. However, implementing a handler is very easy.
+
+=== What this plugin is NOT
+
+This plugin is NOT a background processing framework. To make it work
+efficiently, you need an existing framework installed and configured. Right now,
+support for the ActiveMessaging framework is implemented.
+
+However, there is out-of-the-box support for using script/runner to perform
+background tasks, as well as forking.
+
+=== When to use it
+
+* Your Rails process gets unresponsive due to some time-consuming task.
+* The task does not need to show an immediate effect.
+
+=== Features
+
+* Background processing using multiple background processing frameworks.
+* Fallback processing, if your background processing framework isn't responding
+  correctly.
+* Works out-of-the-box with script/runner and forking.
+* Fallback handler that streams messages containing background tasks to disk, to
+  later .
+* Error reporting through different channels, depending on the task at hand.
+  * Exception notification.
+  * Stdout (useful for debugging).
+  * Stderr (useful for debugging).
+  * Silent, which swallows all exceptions.
+* Supported processing frameworks.
+  * ActiveMessaging.
+  * script/runner.
+  * fork (works only on Unix-like environments).
+  * others might follow (it's really easy to write a handler).
+* Easy configuration, depending on the environment, in config/background.yml.
+* Ability to override the configuration per method.
+
+=== Dependencies
+
+There are no dependencies besides ActiveSupport, which is required by Rails
+anyways.
+
+=== Installation
+
+Just copy the background_lite folder into vendor/plugins, and you're good to go.
+
+=== Configuration
+
+Depending on the background processing framework that you are using, you might
+have to do some configuration. See the documentation of the respective
+background handler for details.
+
+Copyright (c) 2008-2009 imedo GmbH, released under the MIT license

data/init.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/lib/background'
+require File.dirname(__FILE__) + '/lib/core_ext/object'
+require File.dirname(__FILE__) + '/lib/core_ext/class'
+require File.dirname(__FILE__) + '/lib/core_ext/numeric'
+require File.dirname(__FILE__) + '/lib/core_ext/symbol'
+require File.dirname(__FILE__) + '/lib/core_ext/nil_class'
+Dir.glob(File.dirname(__FILE__) + '/lib/core_ext/handlers/*.rb').each do |handler|
+  require handler
+end
+Dir.glob(File.dirname(__FILE__) + '/lib/core_ext/error_reporters/*.rb').each do |reporter|
+  require reporter
+end
+require File.dirname(__FILE__) + '/lib/rails_ext/activerecord/base'

data/lib/background.rb

@@ -0,0 +1,100 @@
+# This module holds methods for background handling
+module BackgroundLite
+  # This class is for configuring defaults of the background processing
+  # framework(s) you use. You can configure the frameworks either using the
+  # accessors in this class, or by listing them in the config/background.yml
+  # configuration file. See Class#background_method for details.
+  class Config
+    # Contains the default background handler that is chosen, if none is
+    # specified in the call to Kernel#background.
+    @@default_handler = [:in_process, :forget]
+    cattr_accessor :default_handler
+    
+    # Contains the default error reporter.
+    @@default_error_reporter = :stdout
+    cattr_accessor :default_error_reporter
+    
+    def self.config #:nodoc:
+      @config ||= YAML.load(File.read("#{RAILS_ROOT}/config/background.yml")) rescue { RAILS_ENV => {} }
+    end
+    
+    def self.default_config #:nodoc:
+      @default_config ||= (config['default'] || {})
+    end
+    
+    def self.load(configuration) #:nodoc:
+      if configuration.blank?
+        default_config
+      else
+        loaded_config = ((config[RAILS_ENV] || {})[configuration] || {})
+        default_config.merge(loaded_config.symbolize_keys || {})
+      end
+    end
+  end
+  
+  # holds whether or not background handling is disabled.
+  mattr_accessor :disabled
+  self.disabled = false
+  
+  # Disables background handling.
+  def self.disable!
+    BackgroundLite.disabled = true
+  end
+  
+  # Enables background handling.
+  def self.enable!
+    BackgroundLite.disabled = false
+  end
+  
+  # Disables background handling for the given block.
+  def self.disable(&block)
+    value = BackgroundLite.disabled
+    begin
+      BackgroundLite.disable!
+      yield
+    ensure
+      BackgroundLite.disabled = value
+    end
+  end
+  
+  # Sends a message to the background. The message contains an object, a method,
+  # and the methods arguments. The object and the arguments will be cloned for
+  # background handling.
+  #
+  # The options hash lets you choose the background handler(s) and their
+  # configuration, if available.
+  #
+  # You should rarely need to use this method directly. Rather use
+  # Class#background_method to mark a method to be executed in the background.
+  def self.send_to_background(object, method, args = [], options = {})
+    object = object.clone_for_background
+    args = args.collect { |a| a.clone_for_background }
+    
+    config = (BackgroundLite::Config.load(options[:config].to_s) || {})
+    handler = if BackgroundLite.disabled
+      [:in_process]
+    else
+      [options.delete(:handler) || config[:handler] || BackgroundLite::Config.default_handler].flatten
+    end
+    reporter = options.delete(:reporter) || config[:reporter] || BackgroundLite::Config.default_error_reporter
+    
+    handler.each do |hand|
+      options = {}
+      if hand.is_a? Hash
+        raise "Malformed handler options Hash" if hand.keys.size != 1
+        options = hand.values.first
+        hand = hand.keys.first
+      end
+      
+      begin
+        BackgroundLite.disable do
+          "BackgroundLite::#{hand.to_s.camelize}Handler".constantize.handle(object, method, args, options)
+        end
+        
+        return hand
+      rescue Exception => e
+        "BackgroundLite::#{reporter.to_s.camelize}ErrorReporter".constantize.report(e)
+      end
+    end
+  end
+end

data/lib/core_ext/class.rb

@@ -0,0 +1,113 @@
+class Class
+  def clone_for_background
+    self
+  end
+
+  # Decorates a method to be executed in the background.
+  #
+  # To decorate a class' method, background_method must be called from inside a
+  # class and the first argument must be a symbol, containing the name of the
+  # method to decorate.
+  #
+  #    class FactorialClass
+  #      def factorial(number)
+  #        result = (1..number).inject(1) { |num, res| res * num }
+  #        Logger.log("The result is #{result}")
+  #      end
+  #
+  #      # execute all calls to FactorialClass#factorial in the background
+  #      background_method :factorial
+  #    end
+  #
+  # === Choosing a handler
+  #
+  # There are several ways to execute a task in the background. To choose your
+  # particular handler and optionally some fallback handlers, in case the
+  # background process doesn't respond, use the :handler option.
+  #
+  #    background_method :handler => [:active_messaging, :disk]
+  #
+  # To configure a handler, use a Hash instead of a Symbol like this:
+  #
+  #    background_method :handler => [{ :active_messaging => { :queue => :my_queue } }, :disk]
+  #
+  # === Options
+  #
+  # handler:: The background handler to use.
+  #           If none is specified, the BackgroundLite::Config.default_handler
+  #           is used. Available handlers are :active_messaging, :in_process,
+  #           :forget, :disk, and :test. This option can also be an array, in
+  #           which case all of the handlers are tried in order, until one
+  #           succeeds. Each element of the array may be a Symbol or a hash with
+  #           one element. If it is a hash, the key is the handler name, and the
+  #           value contains configuration options for the handler.
+  #
+  # reporter:: A reporter class that reports errors to the user. Available
+  #            reporters are :stdout, :silent, :exception_notification, and
+  #            :test.
+  #
+  # === Background Configurations
+  #
+  # Instead of specifying the :handler: and :reporter: params directly, you can
+  # also specify a configuration for your particular background call, which is
+  # configured in RAILS_ROOT/config/background.yml. This file has the following
+  # format:
+  #
+  #    test:
+  #      queue:
+  #        :handler: test
+  #        :reporter: silent
+  #    production
+  #      queue:
+  #        :handler:
+  #        - :active_messaging:
+  #            :queue: background
+  #        :reporter: exception_notification
+  #
+  # You can also specify a default configuration like this:
+  #
+  #    default:
+  #      :handler:
+  #      - :in_process:
+  #      - :disk:
+  #
+  # === Precedence
+  #
+  # For the handler and reporter options, the precedence is as follows, from
+  # high to low:
+  #
+  # - method argument
+  # - background.yml configuration, if supplied
+  # - background.yml default configuration
+  # - BackgroundLite::Config.default_handler / BackgroundLite::Config.default_error_reporter
+  #
+  # === Writing own handlers
+  #
+  # Writing handlers is easy. A background handler class must implement a
+  # self.handle method that accepts a hash containing local variables as well as
+  # an options hash for the block to execute. An error reporter must implement a
+  # self.report method that accepts an exception object. Note that for most
+  # non-fallback handlers you need to write a background task that accepts and
+  # executes the block. See BackgroundLite::ActiveMessagingHandler for an
+  # example on how to do that.
+  #
+  # === Things to note
+  #
+  # * Since it is not possible to serialize singleton objects, all objects are
+  #   dup'ed before serialization. This means that all singleton methods get
+  #   stripped away on serialization.
+  # * Every class used in a background method must be available in the
+  #   background process as well.
+  # * Subject to the singleton restriction mentioned above, the self object is
+  #   correctly and automatically serialized and can be referenced in the
+  #   background method using the self keyword.
+  def background_method(method, options = {})
+    alias_method_chain method, :background do |aliased_target, punctuation|
+      self.class_eval do
+        define_method "#{aliased_target}_with_background#{punctuation}" do |*args|
+          BackgroundLite.send_to_background(self, "#{aliased_target}_without_background#{punctuation}", args, options)
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/error_reporters/exception_notification_error_reporter.rb

@@ -0,0 +1,47 @@
+class MockController #:nodoc:
+  def controller_name
+    "BackgroundLite"
+  end
+  def action_name
+    "send_to_background"
+  end
+end
+
+class MockRequest #:nodoc:
+  attr_accessor :format
+  
+  def initialize(message, options = {})
+    @message = message
+    options.each do |k, v|
+      self.instance_variable_set(:"@#{k}", v)
+    end
+  end
+
+  def env
+    {}
+  end
+  def protocol
+    "none"
+  end
+  def request_uri
+    "none"
+  end
+  def parameters
+    @message || "nil message. this does not happen (TM)."
+  end
+  def session
+    "none"
+  end
+end
+
+module BackgroundLite
+  # Notifies developers about errors per e-mail.
+  class ExceptionNotificationErrorReporter
+    # This method uses the exception notification plugin to deliver the exception
+    # together with a backtrace to the developers. Refer to the ExceptionNotification
+    # documentation for details.
+    def self.report(error)
+      ExceptionNotifier.deliver_exception_notification(error, MockController.new, MockRequest.new(error.message), {})
+    end
+  end
+end

data/lib/core_ext/error_reporters/silent_error_reporter.rb

@@ -0,0 +1,9 @@
+module BackgroundLite
+  # Does not report errors at all.
+  class SilentNotificationErrorReporter
+    # Suppresses the error message by not reporting anything.
+    def self.report(error)
+      # do nothing
+    end
+  end
+end

data/lib/core_ext/error_reporters/stderr_error_reporter.rb

@@ -0,0 +1,9 @@
+module BackgroundLite
+  # Reports error on $stdout.
+  class StderrErrorReporter
+    # Prints the exception's error message on $stderr.
+    def self.report(error)
+      $stderr.puts error.message
+    end
+  end
+end

data/lib/core_ext/error_reporters/stdout_error_reporter.rb

@@ -0,0 +1,10 @@
+module BackgroundLite
+  # Reports error on $stdout.
+  class StdoutErrorReporter
+    # Prints the exception's error message on $stdout.
+    def self.report(error)
+      puts error.message
+      puts error.backtrace
+    end
+  end
+end

data/lib/core_ext/error_reporters/test_error_reporter.rb

@@ -0,0 +1,11 @@
+module BackgroundLite
+  # This class is used for reporting errors in a test environment.
+  class TestErrorReporter
+    # Stores the last error
+    cattr_accessor :last_error
+    # Does not actually report any error, but stores it in last_error.
+    def self.report(error)
+      self.last_error = error
+    end
+  end
+end

data/lib/core_ext/handlers/active_messaging_handler.rb

@@ -0,0 +1,65 @@
+module BackgroundLite
+  # This background handler sends the method as well as the arguments through
+  # ActiveMessaging to the background poller. If you don't use the
+  # ActiveMessaging plugin, then this handler won't work.
+  # 
+  # To make the background_lite plugin work with ActiveMessaging, you need to
+  # put the following processor in app/processors:
+  #
+  #   class BackgroundProcessor < ApplicationProcessor
+  #     subscribes_to :background
+  #   
+  #     def on_message(message)
+  #       puts "BackgroundProcessor"
+  #       BackgroundLite::ActiveMessagingHandler.execute(message)
+  #     end
+  #   end
+  class ActiveMessagingHandler
+    # The ActiveMessaging queue name through which the message should be
+    # serialized.
+    @@queue_name = :background
+    cattr_accessor :queue_name
+    
+    # Marshals the method and the arguments and sends it through ActiveMessaging
+    # to the background processor.
+    #
+    # === Options
+    #
+    # queue:: The name of the queue to use to send the message to the background
+    #         process.
+    def self.handle(object, method, args, options = {})
+      ActiveMessaging::Gateway.publish((options[:queue] || self.queue_name).to_sym, Marshal.dump([object, method, args]))
+    end
+    
+    # Decodes a marshalled message which was previously sent over
+    # ActiveMessaging. Returns an array containing the object, the method name
+    # as a string, and the method arguments.
+    def self.decode(message)
+      begin
+        object, method, args = Marshal.load(message)
+      rescue ArgumentError => e
+        # Marshal.load does not trigger const_missing, so we have to do this
+        # ourselves.
+        e.message.split(' ').last.constantize
+        retry
+      end
+      [object, method, args]
+    end
+    
+    # Executes a marshalled message which was previously sent over
+    # ActiveMessaging, in the context of the object, with all the arguments
+    # passed.
+    def self.execute(message)
+      begin
+        object, method, args = self.decode(message)
+        puts "--- executing method: #{method}\n--- with variables: #{args.inspect}\n--- in object: #{object.class.name}, #{object.id}"
+
+        object.send(method, *args)
+        puts "--- it happened!"
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+      end
+    end
+  end
+end

data/lib/core_ext/handlers/disk_handler.rb

@@ -0,0 +1,32 @@
+module BackgroundLite
+  # Stores the serialized message on disk. This handler is probably most useful
+  # as a fallback handler.
+  class DiskHandler
+    # The directory in which the serialized messages should be stored.
+    @@dirname = nil
+    cattr_accessor :dirname
+    
+    # Marshals the message and the locals into a file in the folder specified by
+    # dirname.
+    def self.handle(object, method, args, options = {})
+      filename = "background_#{Time.now.to_f.to_s}"
+      File.open("#{dirname}/#{filename}", 'w') do |file|
+        file.print(Marshal.dump([object, method, args]))
+      end
+    end
+    
+    # Replays all marshalled background tasks in the order in which they were
+    # stored into the folder specified by dirname.
+    def self.recover(handler)
+      handler_class = "BackgroundLite::#{handler.to_s.camelize}Handler".constantize
+      Dir.entries(dirname).grep(/^background/).sort.each do |filename|
+        path = "#{dirname}/#{filename}"
+        File.open(path, 'r') do |file|
+          object, method, args = Marshal.load(file)
+          handler_class.handle(object, method, args)
+        end
+        FileUtils.rm(path)
+      end
+    end
+  end
+end

data/lib/core_ext/handlers/drb_handler.rb

@@ -0,0 +1,51 @@
+module BackgroundLite
+  # This background handler sends the method as well as the arguments through
+  # DRb to the background process.
+  class DrbHandler
+    def self.background_queue
+      @background_queue ||= begin
+        require 'drb'
+        
+        DRb.start_service
+        DRbObject.new(nil, "druby://localhost:2251")
+      end
+    end
+    
+    # Marshals the method and the arguments and sends it through DRb
+    # to the background process.
+    def self.handle(object, method, args, options = {})
+      background_queue.push(Marshal.dump([object, method, args]))
+    end
+    
+    # Decodes a marshalled message which was previously sent over
+    # DRb. Returns an array containing the object, the method name
+    # as a string, and the method arguments.
+    def self.decode(message)
+      begin
+        object, method, args = Marshal.load(message)
+      rescue ArgumentError => e
+        # Marshal.load does not trigger const_missing, so we have to do this
+        # ourselves.
+        e.message.split(' ').last.constantize
+        retry
+      end
+      [object, method, args]
+    end
+    
+    # Executes a marshalled message which was previously sent over
+    # DRb, in the context of the object, with all the arguments
+    # passed.
+    def self.execute(message)
+      begin
+        object, method, args = self.decode(message)
+        puts "--- executing method: #{method}\n--- with variables: #{args.inspect}\n--- in object: #{object.class.name}, #{object.id}"
+
+        object.send(method, *args)
+        puts "--- it happened!"
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+      end
+    end
+  end
+end

data/lib/core_ext/handlers/forget_handler.rb

@@ -0,0 +1,10 @@
+module BackgroundLite
+  # Forgets the background task. This handler is probably most useful as a
+  # fallback handler.
+  class ForgetHandler
+    # Does nothing
+    def self.handle(object, method, args, options = {})
+      # do nothing
+    end
+  end
+end

data/lib/core_ext/handlers/fork_handler.rb

@@ -0,0 +1,11 @@
+module BackgroundLite
+  # This background handler runs the given method in a forked child process.
+  class ForkHandler
+    # Runs the method in a forked child process
+    def self.handle(object, method, args, options = {})
+      fork do
+        object.send(method, *args)
+      end
+    end
+  end
+end

data/lib/core_ext/handlers/in_process_handler.rb

@@ -0,0 +1,10 @@
+module BackgroundLite
+  # Executes the method in-process. This handler is probably most useful as a
+  # fallback handler.
+  class InProcessHandler
+    # Executes the method in-process.
+    def self.handle(object, method, args, options = {})
+      object.send(method, *args)
+    end
+  end
+end

data/lib/core_ext/handlers/resque_handler.rb

@@ -0,0 +1,45 @@
+module BackgroundLite
+  # This background handler sends the method as well as the arguments through
+  # Resque to the background process.
+  class ResqueHandler
+    @queue = :background
+    
+    # Marshals the method and the arguments and sends it through Resque
+    # to the background process.
+    def self.handle(object, method, args, options = {})
+      require 'resque'
+      Resque.enqueue(self, Base64.encode64(Marshal.dump([object, method, args])))
+    end
+    
+    # Decodes a marshalled message which was previously sent over
+    # Resque. Returns an array containing the object, the method name
+    # as a string, and the method arguments.
+    def self.decode(message)
+      begin
+        object, method, args = Marshal.load(Base64.decode64(message))
+      rescue ArgumentError => e
+        # Marshal.load does not trigger const_missing, so we have to do this
+        # ourselves.
+        e.message.split(' ').last.constantize
+        retry
+      end
+      [object, method, args]
+    end
+    
+    # Executes a marshalled message which was previously sent over
+    # Resque, in the context of the object, with all the arguments
+    # passed.
+    def self.perform(message)
+      begin
+        object, method, args = self.decode(message)
+        puts "--- executing method: #{method}\n--- with variables: #{args.inspect}\n--- in object: #{object.class.name}, #{object.id}"
+
+        object.send(method, *args)
+        puts "--- it happened!"
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+      end
+    end
+  end
+end

data/lib/core_ext/handlers/runner_handler.rb

@@ -0,0 +1,40 @@
+require 'base64'
+
+module BackgroundLite
+  # This background handler runs the method block via script/runner.
+  class RunnerHandler
+    # Marshals the method and arguments and sends them to script/runner.
+    def self.handle(object, method, args, options = {})
+      fork do
+        system(%{script/runner "BackgroundLite::RunnerHandler.execute '#{encode(object)}', '#{method}', '#{encode(args)}'"})
+      end
+    end
+    
+    # Executes an encoded message which was sent via command line to runner
+    def self.execute(object, method, args)
+      object, args = self.decode(object), self.decode(args)
+      puts "--- executing method: #{method}\n--- with variables: #{args.inspect}\n--- in object: #{object.inspect}"
+      
+      object.send(method, *args)
+      puts "--- it happened!"
+    end
+  
+  protected
+    def self.encode(obj)
+      Base64.encode64(Marshal.dump(obj))
+    end
+  
+    def self.decode(string)
+      message = Base64.decode64(string)
+      begin
+        obj = Marshal.load(message)
+      rescue ArgumentError => e
+        # Marshal.load does not trigger const_missing, so we have to do this
+        # ourselves.
+        e.message.split(' ').last.constantize
+        retry
+      end
+      obj
+    end
+  end
+end

data/lib/core_ext/handlers/test_handler.rb

@@ -0,0 +1,35 @@
+module BackgroundLite
+  # This handler is used in a testing environment. It allows for introspection
+  # of last call to the handle method.
+  class TestHandler
+    # contains the object on which the method is executed.
+    cattr_accessor :object
+    # contains the method name to execute
+    cattr_accessor :method
+    # contains the method's arguments
+    cattr_accessor :args
+    # If true, the execution of TestHandler#handle will fail the next time it's
+    # called.
+    cattr_accessor :fail_next_time
+    # True, if TestHandler#handle was executed.
+    cattr_accessor :executed
+    # Stores the last options hash given to handle
+    cattr_accessor :options
+    
+    # Does not call the block, but sets some variables for introspection.
+    def self.handle(object, method, args, options = {})
+      self.executed = true
+      if self.fail_next_time
+        self.fail_next_time = false
+        raise "TestHandler.handle: Failed on purpose"
+      end
+      
+      self.object, self.method, self.args, self.options = object, method, args, options
+    end
+    
+    # Resets the class' accessors.
+    def self.reset
+      object = method = args = options = fail_next_time = executed = nil
+    end
+  end
+end

data/lib/core_ext/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def clone_for_background
+    self
+  end
+end

data/lib/core_ext/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def clone_for_background
+    self
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,7 @@
+class Object
+  # Clones the object to for transmission to the background process. The default
+  # implementation is dupping the object.
+  def clone_for_background
+    dup
+  end
+end

data/lib/core_ext/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def clone_for_background
+    self
+  end
+end

data/lib/rails_ext/activerecord/base.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  class Base
+    # Override this method to strip your object from data that doesn't have to
+    # be transmitted to the background process. Note that you don't need to
+    # clear the association cache, as this is already done for you in
+    # clone_for_background.
+    def cleanup_for_background
+    end
+    
+    # Prepares the object to be transmitted to the background. This method dups
+    # the object and strips some instance variables, most notably the
+    # association cache, in order to prevent all associations to be transmitted
+    # with the object in full length.
+    #
+    # To clean up data specific to your class, use cleanup_for_background.
+    def clone_for_background
+      returning dup do |x|
+        x.cleanup_for_background
+        
+        # taken from ActiveRecord::AttributeMethods::ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+        type_to_preserve = [DateTime, Time, Date]
+        attr_cache = x.instance_variable_get(:@attributes_cache)
+        attr_cache.each do |key, value|
+          attr_cache[key] = nil unless type_to_preserve.include?(attr_cache[key].class)
+        end
+        x.instance_variable_set(:@errors, nil)
+        x.clear_association_cache
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../init'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: background_lite
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Kadauke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-17 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: tkadauke@imedo.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/background.rb
+- lib/core_ext/class.rb
+- lib/core_ext/error_reporters/exception_notification_error_reporter.rb
+- lib/core_ext/error_reporters/silent_error_reporter.rb
+- lib/core_ext/error_reporters/stderr_error_reporter.rb
+- lib/core_ext/error_reporters/stdout_error_reporter.rb
+- lib/core_ext/error_reporters/test_error_reporter.rb
+- lib/core_ext/handlers/active_messaging_handler.rb
+- lib/core_ext/handlers/disk_handler.rb
+- lib/core_ext/handlers/drb_handler.rb
+- lib/core_ext/handlers/forget_handler.rb
+- lib/core_ext/handlers/fork_handler.rb
+- lib/core_ext/handlers/in_process_handler.rb
+- lib/core_ext/handlers/resque_handler.rb
+- lib/core_ext/handlers/runner_handler.rb
+- lib/core_ext/handlers/test_handler.rb
+- lib/core_ext/nil_class.rb
+- lib/core_ext/numeric.rb
+- lib/core_ext/object.rb
+- lib/core_ext/symbol.rb
+- lib/rails_ext/activerecord/base.rb
+- rails/init.rb
+- init.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://www.imedo.de/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Run any method in the background
+test_files: []
+