simonmenke-background_services 0.0.2

data/README.textile

@@ -0,0 +1,24 @@
+h2. LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Simon Menke
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/background_services

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-9-26.
+#  Copyright (c) 2008. All rights reserved.
+
+begin
+  require File.join(File.dirname(__FILE__), '../lib/background_services.rb')
+rescue LoadError
+  # no rubygems to load, so we fail silently
+  require 'rubygems'
+  require 'background_services'
+end
+
+BackgroundServices::Client.setup
+BackgroundServices::Client.run!

data/bin/background_servicesd

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-9-26.
+#  Copyright (c) 2008. All rights reserved.
+
+begin
+  require File.join(File.dirname(__FILE__), '../lib/background_services.rb')
+rescue LoadError
+  # no rubygems to load, so we fail silently
+  require 'rubygems'
+  require 'background_services'
+end
+
+BackgroundServices::Server.setup
+BackgroundServices::Server.run!

data/lib/background_services.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'beanstalk-client'
+require 'thread'
+require 'timeout'
+require 'logger'
+require 'singleton'
+require 'optparse'
+require 'daemons'
+require 'drb'
+
+# HACK
+class DRb::DRbTCPSocket
+  class << self
+    alias parse_uri_orig parse_uri
+    def parse_uri(*args)
+      ary = parse_uri_orig(*args)
+      ary[1] = (rand(100_000)+50_000) if ary[1] == 0
+      ary
+    end
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'bs')
+require File.join(File.dirname(__FILE__), 'background_services/client')
+require File.join(File.dirname(__FILE__), 'background_services/server')
+require File.join(File.dirname(__FILE__), 'background_services/dsl')
+require File.join(File.dirname(__FILE__), 'background_services/team')
+require File.join(File.dirname(__FILE__), 'background_services/group')
+require File.join(File.dirname(__FILE__), 'background_services/service')
+require File.join(File.dirname(__FILE__), 'background_services/worker')
+require File.join(File.dirname(__FILE__), 'background_services/version')
+require File.join(File.dirname(__FILE__), 'background_services/team_controller')
+
+module BackgroundServices
+  
+end

data/lib/background_services/client.rb

@@ -0,0 +1,154 @@
+module BackgroundServices
+  class Client
+    
+    include Singleton
+    include DRbUndumped
+    
+    def self.load(*args)
+      include.load(*args)
+    end
+    
+    def self.run!
+      instance.run!
+    end
+    
+    def self.setup
+      instance.setup
+    end
+    
+    attr_accessor :options
+    
+    def setup
+      parse_options
+      start_drb_client
+    end
+    
+    def parse_options
+      @options = {
+        :log => STDOUT,
+        :host => "127.0.0.1:5000"
+      }
+      @opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options]"
+        
+        opts.separator ""
+        opts.separator "Client options: "
+        
+        opts.on("--stop", "Stop the server") do |v|
+          options[:client_service] = :stop
+        end
+        
+        opts.on("-l", "--list WHAT", [:groups, :teams, :services], "list (teams, services, groups)") do |v|
+          options[:client_service] = "list_#{v}".intern
+        end
+        
+        opts.on("-T", "--stop-team ID", "Stop a team") do |v|
+          options[:client_service] = :stop_team
+          options[:team_id] = v.to_i
+        end
+        
+        opts.on("-t", "--start-team ID", "Start a team") do |v|
+          options[:client_service] = :start_team
+          options[:team_id] = v.to_i
+        end
+        
+        opts.on("-G", "--stop-group A,B,C", Array, "Stop a group or an intersection of groups") do |v|
+          options[:client_service] = :stop_group
+          options[:groups] = v.collect{|g|g.intern}
+        end
+        
+        opts.on("-g", "--start-group A,B,C", Array, "Start a group or an intersection of groups") do |v|
+          options[:client_service] = :start_group
+          options[:groups] = v.collect{|g|g.intern}
+        end
+        
+        opts.on("-H", "--host HOST", "Server location") do |v|
+          options[:host] = v
+        end
+        
+        opts.on_tail("-h", "--help", "Show this message") do |v|
+          puts opts
+          exit
+        end
+        
+      end
+      @opts.parse!
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, OptionParser::MissingArgument
+      puts @opts
+      exit(1)
+    end
+    
+    def start_drb_client
+      DRb.start_service
+      @app = DRbObject.new_with_uri "druby://"+@options[:host]
+    end
+    
+    def run!
+      begin
+        send "client_perform_#{@options[:client_service]}"
+      rescue Errno::ECONNREFUSED, DRb::DRbConnError => e
+        puts "Could not connect to host! (#{e.inspect})"
+        # puts @opts
+        exit(1)
+      end
+    end
+    
+    def client_perform_stop
+      begin
+        @app.stop!
+      rescue DRb::DRbConnError
+      end
+    end
+    
+    def client_perform_list_services
+      @app.services.keys.each do |name|
+        puts "- #{name}"
+      end
+    end
+    
+    def client_perform_list_teams
+      first = true
+      @app.team_controllers.each do |id, controller|
+        team = controller.team
+        service = team.service
+        puts unless first
+        first = false
+        puts "- #{service.name}[#{id}] (#{team.size} workers - #{controller.running? ? "running" : "stopped"})"
+        puts "  hosts: #{team.hosts.join(', ')}"
+        puts "  tubes: #{team.tubes.join(', ')}"
+        puts "  groups: #{team.groups.join(', ')}"
+      end
+    end
+    
+    def client_perform_list_groups
+      @app.groups.keys.each do |name|
+        puts "- #{name}"
+      end
+    end
+    
+    def client_perform_stop_team
+      @app.team_controllers[@options[:team_id]].stop
+    end
+    
+    def client_perform_start_team
+      @app.team_controllers[@options[:team_id]].start
+    end
+    
+    def client_perform_start_group
+      group = @options[:groups].inject(nil) do |m, g|
+        m = m.union(@app.groups[g]) unless m.nil?
+        m ||= @app.groups[g]
+      end
+      group.start
+    end
+    
+    def client_perform_stop_group
+      group = @options[:groups].inject(nil) do |m, g|
+        m = m.union(@app.groups[g]) unless m.nil?
+        m ||= @app.groups[g]
+      end
+      group.stop
+    end
+    
+  end
+end

data/lib/background_services/dsl.rb

@@ -0,0 +1,66 @@
+module BackgroundServices
+  
+  class DSL
+      
+    def team()
+      builder = BackgroundServices::DSL::TeamBuilder.new
+      yield(builder)
+      BackgroundServices::Server.register_team(builder.build)
+    end
+    
+    def service(name, klass_or_module=nil, &block)
+      service = BackgroundServices::Service.new(name, klass_or_module || block)
+      BackgroundServices::Server.register_service(service)
+    end
+    
+    def self.load(*paths)
+      paths.collect do |path|
+        Dir.glob(File.expand_path(path)).each do |realpath|
+          if File.exists?(realpath)
+            code = File.read(realpath)
+            Dir.chdir(File.dirname(realpath)) do
+              dsl = self.new
+              dsl.instance_eval(code, realpath)
+              dsl
+            end
+          else
+            nil
+          end
+        end
+      end
+    end
+    
+    class TeamBuilder
+      def initialize
+        @hosts  = Array.new
+        @groups = Array.new
+        @tubes  = Array.new
+        @service = nil
+        @size   = 2
+      end
+      def host(*hosts)
+        @hosts += hosts
+      end
+      def group(*groups)
+        @groups += groups
+      end
+      def tube(*tubes)
+        @tubes = tubes
+      end
+      def service(name)
+        @service = name
+      end
+      def size(size)
+        @size = size
+      end
+      
+      def build
+        raise "Missing service" if @service == nil
+        raise "Must have at lease one host" if @hosts.empty?
+        BackgroundServices::Team.new(@service, @size, @tubes, @groups, @hosts)
+      end
+    end
+    
+  end
+  
+end

data/lib/background_services/group.rb

@@ -0,0 +1,41 @@
+module BackgroundServices
+  class Group
+    
+    attr_accessor :name, :teams
+    
+    def initialize(name)
+      @name, @teams = name, {}
+    end
+    
+    def start
+      @teams.each do |k, team|
+        team.start
+      end
+    end
+    
+    def stop
+      @teams.each do |k, team|
+        team.stop
+      end
+    end
+    
+    def register_team(team)
+      @teams[team.team_id] = team
+    end
+    
+    def unregister_team(team)
+      @teams.delete(team.team_id)
+    end
+    
+    def union(other)
+      group = Group.new("#{@name}_and_#{other.name}")
+      ids = @teams.keys & other.teams.keys
+      group.teams = ids.inject({}) do |m, id|
+        m[id] = @teams[id] || other.teams[id]
+        m
+      end
+      group
+    end
+    
+  end
+end

data/lib/background_services/queue.rb

@@ -0,0 +1,8 @@
+module BackgroundServices
+  
+  module Queue
+    
+    
+  end
+  
+end

data/lib/background_services/queue/base.rb

@@ -0,0 +1,70 @@
+module BackgroundServices
+  
+  module Queue
+    
+    class QueueError < Exception ; end
+    
+    class Base
+      
+      attr_accessor :configuration, :adapter
+      
+      def synchronize(timeout=nil, &block)
+        @mutex ||= Mutex.new
+        unless timeout.nil?
+          user_block = block
+          block = Proc.new do
+            Timeout::timeout(timeout, &block)
+          end
+        @mutex.synchronize(&block)
+      rescue => e
+        raise QueueError
+      end
+      
+      def process(&block)
+        job = synchronize(5) do
+          @adapter.dequeue
+        end
+        job.queue = self
+        job.before
+        yield job
+        job.after
+      rescue => e
+        job.recover unless job.nil?
+      end
+      
+      def connect
+        synchronize do
+          @adapter.connect(@configuration || {})
+        end
+      end
+      
+    end
+    
+    class Job
+      
+      attr_accessor :queue
+      def synchronize(&block)
+        @queue.synchronize(&block)
+      end
+      
+      def before
+        
+      end
+      
+      def after
+        
+      end
+      
+      def recover
+        
+      end
+      
+      def payload
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/background_services/queue/beanstalkd.rb

@@ -0,0 +1,52 @@
+module BackgroundServices
+  
+  module Queue
+    
+    class BeanstalkdQueue < BackgroundServices::Queue::Base
+      
+      def connect(configuration)
+        @connection = Beanstalk::Pool.new(configuration['hosts'])
+        
+        tubes = configuration['tubes'] || []
+        unless tubes.empty?
+        tubes.each do |tube|
+          @connection.watch(tube)
+        end
+        @connection.ignore("default")
+      end
+      
+      def dequeue
+        BeanstalkdJob.new(@connection.reserve)
+      end
+      
+    end
+    
+    class BeanstalkdJob < BackgroundServices::Queue::Job
+      
+      attr_reader :private_job
+      
+      def initialize(job)
+        @private_job=nil
+      end
+      
+      def payload
+        @private_job.body
+      end
+      
+      def after
+        synchronize do
+          @private_job.delete
+        end
+      end
+      
+      def recover
+        synchronize do
+          @private_job.put_back
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/background_services/server.rb

@@ -0,0 +1,226 @@
+module BackgroundServices
+  class Server
+    
+    include Singleton
+    include DRbUndumped
+    
+    def self.load(*args)
+      include.load(*args)
+    end
+    
+    def self.logger
+      instance.logger
+    end
+    
+    def self.setup
+      instance.setup
+    end
+    
+    def self.run!
+      instance.run!
+    end
+    
+    def self.stop!
+      instance.stop!
+    end
+    
+    def self.register_team(team)
+      instance.register_team(team)
+    end
+    
+    def self.register_service(service)
+      instance.register_service(service)
+    end
+    
+    attr_accessor :logger
+    attr_accessor :options
+    attr_accessor :team_controllers
+    attr_accessor :services
+    attr_accessor :groups
+    
+    def initialize
+      @services = Hash.new
+      @team_controllers = Hash.new
+      @groups = Hash.new { |h, k| h[k] = BackgroundServices::Group.new(k) }
+    end
+    
+    def setup
+      parse_options
+      damonize
+      setup_logger
+      load_files
+      register_signal_handlers
+      start_drb_server
+    end
+    
+    def parse_options
+      @options = {
+        :log => STDOUT,
+        :level => Logger::INFO,
+        :files => [],
+        :run_server => true,
+        :host => "127.0.0.1:5000",
+        :daemonize => false
+      }
+      @opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options]"
+        opts.separator ""
+        opts.separator "Server options: "
+        
+        opts.on("-c", "--config CONFIG_FILE", "Path to a configuration file") do |v|
+          options[:files] << File.expand_path(v)
+        end
+        
+        opts.on("-L", "--log LOG_FILE", "Path to the log file") do |v|
+          options[:log] = File.expand_path(v)
+        end
+        
+        opts.on("-d", "--daemonize", "Run in the background") do |v|
+          options[:daemonize] = true
+        end
+        
+        opts.on("-H", "--host HOST", "Server location") do |v|
+          options[:host] = v
+        end
+        
+        opts.on("--debug", "Run in debugging mode") do |v|
+          options[:level] = Logger::DEBUG
+          require 'ruby-debug'
+        end
+        
+        opts.on_tail("-h", "--help", "Show this message") do |v|
+          puts opts
+          exit
+        end
+        
+      end
+      @opts.parse!
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, OptionParser::MissingArgument
+      puts @opts
+      exit(1)
+    end
+    
+    def setup_logger
+      @logger = Logger.new(options[:log])
+      @logger.level = options[:level]
+    end
+    
+    def load_files
+      @options[:files].each do |file|
+        DSL.load(file)
+      end
+    end
+    
+    def start_drb_server
+      DRb.start_service "druby://"+@options[:host], self
+      puts "listening on: #{DRb.uri}"
+    end
+    
+    def damonize
+      Daemons.daemonize if options[:daemonize]
+    end
+    
+    def register_signal_handlers
+      terminator = Proc.new do
+        BackgroundServices::Server.stop!
+      end
+      Signal.trap('TERM', terminator)
+      Signal.trap('QUIT', terminator)
+      Signal.trap('INT',  terminator)
+      Signal.trap("CHLD") do
+        @team_controllers.each do |id, controller|
+          controller.check_process
+        end
+      end
+    end
+    
+    def register_team(team)
+      @logger.debug "Registered team: #{team.inspect}"
+      @team_controllers[team.id] = BackgroundServices::TeamController.new(team)
+    end
+    
+    def register_service(service)
+      @logger.debug "Registered service: #{service.name}"
+      @services[service.name] = service
+    end
+    
+    def run!
+      @team_controllers.each do |id, controller|
+        controller.start unless controller.running?
+      end
+      Process.waitall
+      sleep(0.5) until @stopped
+    end
+    
+    def stop!
+      @team_controllers.each do |id, controller|
+        controller.stop if controller.running?
+      end
+      DRb.stop_service
+      @stopped = true
+    end
+    
+    def next_team_id
+      @next_team_id ||= 0
+      @next_team_id += 1
+    end
+    
+    def client_perform_stop
+      begin
+        @app.stop!
+      rescue DRb::DRbConnError
+      end
+    end
+    
+    def client_perform_list_services
+      @app.services.keys.each do |name|
+        puts "- #{name}"
+      end
+    end
+    
+    def client_perform_list_teams
+      first = true
+      @app.team_controllers.each do |id, controller|
+        team = controller.team
+        service = team.service
+        puts unless first
+        first = false
+        puts "- #{service.name}[#{id}] (#{team.size} workers - #{controller.running? ? "running" : "stopped"})"
+        puts "  hosts: #{team.hosts.join(', ')}"
+        puts "  tubes: #{team.tubes.join(', ')}"
+        puts "  groups: #{team.groups.join(', ')}"
+      end
+    end
+    
+    def client_perform_list_groups
+      @app.groups.keys.each do |name|
+        puts "- #{name}"
+      end
+    end
+    
+    def client_perform_stop_team
+      @app.team_controllers[@options[:team_id]].stop
+    end
+    
+    def client_perform_start_team
+      @app.team_controllers[@options[:team_id]].start
+    end
+    
+    def client_perform_start_group
+      group = @options[:groups].inject(nil) do |m, g|
+        m = m.union(@app.groups[g]) unless m.nil?
+        m ||= @app.groups[g]
+      end
+      group.start
+    end
+    
+    def client_perform_stop_group
+      group = @options[:groups].inject(nil) do |m, g|
+        m = m.union(@app.groups[g]) unless m.nil?
+        m ||= @app.groups[g]
+      end
+      group.stop
+    end
+    
+  end
+end

data/lib/background_services/service.rb

@@ -0,0 +1,64 @@
+module BackgroundServices
+  class Service
+    
+    attr_accessor :name
+    
+    def initialize(name, implementation)
+      @name, @implementation = name, implementation
+    end
+    
+    def start
+      case @implementation
+        when Class  then @implementation.send :start if @implementation.respond_to? :start
+        when Module then @implementation.send :start if @implementation.respond_to? :start
+      end
+    end
+    
+    def stop
+      case @implementation
+        when Class  then @implementation.send :stop if @implementation.respond_to? :stop
+        when Module then @implementation.send :stop if @implementation.respond_to? :stop
+      end
+    end
+    
+    def start_worker(worker)
+      case @implementation
+        when Class
+          worker.implementation = @implementation.new
+          worker.implementation.send :start_worker if worker.implementation.respond_to? :start_worker
+        when Module
+          worker.implementation = @implementation
+          worker.implementation.send :start_worker if worker.implementation.respond_to? :start_worker
+        when Proc
+          worker.implementation = @implementation
+      end
+    end
+    
+    def stop_worker(worker)
+      case @implementation
+        when Class
+          worker.implementation.send :stop_worker if worker.implementation.respond_to? :stop_worker
+          worker.implementation = nil
+        when Module
+          worker.implementation.send :stop_worker if worker.implementation.respond_to? :stop_worker
+          worker.implementation = nil
+        when Proc
+          worker.implementation = nil
+      end
+    end
+    
+    def process_job(worker, job)
+      case @implementation
+        when Class
+          raise "must respond to #process_job" unless worker.implementation.respond_to? :process_job
+          worker.implementation.send :process_job, job
+        when Module
+          raise "must respond to #process_job" unless worker.implementation.respond_to? :process_job
+          worker.implementation.send :process_job, job
+        when Proc
+          worker.implementation.call job
+      end
+    end
+    
+  end
+end

data/lib/background_services/team.rb

@@ -0,0 +1,97 @@
+module BackgroundServices
+  class Team
+    def synchronize(&block)
+      @mutex ||= Mutex.new
+      @mutex.synchronize(&block)
+    end
+    
+    attr_accessor :id
+    attr_accessor :service, :size, :tubes, :groups, :hosts
+    attr_accessor :workers
+    
+    def initialize(service, size, tubes, groups, hosts)
+      @id = BackgroundServices::Server.instance.next_team_id
+      @service, @size, @tubes, @groups, @hosts = service, size, tubes, groups, hosts
+      @tubes  ||= Array.new
+      @groups ||= Array.new
+      @workers  = Array.new
+    end
+  
+    def bind_service
+      return if @service.is_a?(BackgroundServices::Service)
+      @service = BackgroundServices::Server.instance.services[@service]
+    end
+  
+    def full?
+      @workers.size == @size
+    end
+  
+    def empty?
+      @workers.size == 0
+    end
+    
+    def start
+      @running = true
+      @service.start
+      until full?
+        worker = Worker.new(@service, self)
+        @workers << worker
+        @service.start_worker(worker)
+        worker.start
+      end
+    end
+  
+    def stop
+      @running = false
+      conn = @connection
+      @connection = nil
+      conn.close unless conn.nil?
+      @workers.each do |worker|
+        worker.stop
+      end
+    end
+  
+    def join
+      @workers.each do |worker|
+        worker.join
+        @service.stop_worker(worker)
+      end
+      @service.stop
+      @workers = Array.new
+    end
+  
+    def receive_job
+      with_connection do
+        @connection.reserve(1)
+      end
+    end
+      
+    def open_connection
+      @connection = Beanstalk::Pool.new(@hosts)
+      unless @tubes.empty?
+        @tubes.each do |tube|
+          @connection.watch(tube)
+        end
+        @connection.ignore("default")
+      end
+    rescue
+      @connection = nil
+    end
+    
+    def with_connection
+      synchronize do
+        r = nil
+        begin
+          raise Beanstalk::NotConnected if @connection.nil?
+          r = yield
+        rescue IOError , Errno::ECONNREFUSED, Beanstalk::NotConnected
+          sleep(1) and open_connection and retry if @running
+        rescue Beanstalk::TimedOut
+          r = nil
+        end
+        r
+      end
+    end
+    
+  end
+end

data/lib/background_services/team_controller.rb

@@ -0,0 +1,63 @@
+module BackgroundServices
+  class TeamController
+    
+    include DRbUndumped
+    
+    attr_accessor :team
+    
+    def initialize(team)
+      @team = team
+    end
+    
+    def running?
+      @running || false
+    end
+    
+    def team_id
+      @team.id
+    end
+    
+    def check_process
+      return unless running?
+      pid, status = Process.waitpid2(@pid, Process::WNOHANG)
+      if !status.nil? and status.exited?
+        @running = false
+      end
+    end
+    
+    def start
+      return if running?
+      @team.bind_service
+      @team.groups.each do |group|
+        BackgroundServices::Server.instance.groups[group].register_team(self)
+      end
+      
+      BackgroundServices::Server.logger.debug "will start team"
+      @pid = fork do
+        Signal.trap("TERM") do
+          BackgroundServices::Server.logger.debug "will stop team"
+          @team.stop
+        end
+        @team.start
+        BackgroundServices::Server.logger.debug "did start team"
+        @team.join
+        BackgroundServices::Server.logger.debug "did stop team"
+        exit!
+      end
+      @running = true
+    end
+    
+    def stop
+      return unless running?
+      begin
+        Process.kill("TERM", @pid)
+        Process.waitpid(@pid, 0)
+      rescue Errno::ECHILD, Errno::ESRCH
+        # already dead
+      ensure
+        @running = false
+      end
+    end
+    
+  end
+end

data/lib/background_services/version.rb

@@ -0,0 +1,9 @@
+module BackgroundServices
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/background_services/worker.rb

@@ -0,0 +1,43 @@
+module BackgroundServices
+  class Worker
+    attr_reader :team, :service
+    attr_accessor :implementation
+    
+    def initialize(service, team)
+      @team = team
+      @service = service
+      @implementation = nil
+    end
+    def working?
+      @working == true
+    end
+    def stop
+      @working = false
+    end
+    def join
+      @thread.join
+    end
+    def start
+      @working = true
+      @thread = Thread.new(self) do |this|
+      
+        begin
+          while this.working?
+            job = this.team.receive_job
+            unless job.nil?
+              App.logger.info "processing job with id: #{job.id}"
+              this.service.process_job this, job
+              this.team.with_connection { job.delete }
+            else
+              sleep 0.5 if this.working?
+            end
+          end
+        rescue => e
+          puts e.inspect
+          puts e.backtrace
+        end
+      
+      end
+    end
+  end
+end

data/lib/bs.rb

@@ -0,0 +1,9 @@
+
+module BS
+  def self.load(*args)
+    BackgroundServices::DSL.load(*args)
+  end
+  def self.logger
+    BackgroundServices::Server.logger
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: simonmenke-background_services
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Simon Menke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-13 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: beanstalk-client
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.10
+    version: 
+description: 
+email: simon.menke@gmail.com
+executables: 
+- background_services
+- background_servicesd
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/background_services
+- bin/background_servicesd
+- lib/background_services/client.rb
+- lib/background_services/dsl.rb
+- lib/background_services/group.rb
+- lib/background_services/queue/base.rb
+- lib/background_services/queue/beanstalkd.rb
+- lib/background_services/queue.rb
+- lib/background_services/server.rb
+- lib/background_services/service.rb
+- lib/background_services/team.rb
+- lib/background_services/team_controller.rb
+- lib/background_services/version.rb
+- lib/background_services/worker.rb
+- lib/background_services.rb
+- lib/bs.rb
+- README.textile
+has_rdoc: true
+homepage: http://github.com/simonmenke
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: background_services
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Manage larger sets of background workers.
+test_files: []
+