raemon 0.1.2 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/examples/beanstalk.rb

@@ -17,13 +17,10 @@ class JobWorker
     logger.info "=> Stopping worker #{Process.pid}"
     
     @beanstalk.close
-    exit
   end
   
-  def execute
+  def run
     loop do
-      stop if shutting_down?
-    
       begin
         job = @beanstalk.reserve(2)
       rescue Beanstalk::TimedOut
@@ -35,17 +32,18 @@ class JobWorker
         # process job here ...
         job.delete
       end
+      
+      heartbeat!
     end
   end
-
 end
 
 ROOT_DIR = File.expand_path('~')
 
-# Raemon::Master.startup 3, JobWorker, {
+# Raemon::Master.start 3, JobWorker, {
 #   :detach   => true,
 #   :logger   => Logger.new("#{ROOT_DIR}/beanstalk.log"),
 #   :pid_file => "#{ROOT_DIR}/beanstalk.pid"
 # }
 
-Raemon::Master.startup 3, JobWorker
+Raemon::Master.start 3, JobWorker

data/examples/evented.rb

@@ -15,11 +15,10 @@ class EventedJobWorker
     logger.info "=> Stopping worker #{Process.pid}"
     
     EM.stop_event_loop if EM.reactor_running?
-    exit
   end
   
-  def execute
-    EventMachine.run do
+  def run
+    EM.run do
       @queue = EMJack::Connection.new
       
       @queue.each_job(5) do |job|        
@@ -27,21 +26,23 @@ class EventedJobWorker
         # process(job)
         @queue.delete(job)
         
-        stop if shutting_down?
+        heartbeat!
       end
       
       @queue.on_error do |error|
         case error
         when :timed_out
-          # We use the reserve timeout to check if we should shutdown
-          stop if shutting_down?
+          # We use the reserve timeout for the heartbeat
+          heartbeat!
+          
+          # Note: this will only run once.. we need to call the @queue.each_job
+          # again .. maybe put it in a block
         else
           logger.error error.to_s
         end
       end
     end
   end
-
 end
 
-Raemon::Master.startup 2, EventedJobWorker
+Raemon::Master.start 2, EventedJobWorker

data/examples/queue.rb

@@ -0,0 +1,14 @@
+# Use the code below to put some jobs onto the queue to test beanstalk.rb
+# and evented.rb examples
+
+require 'rubygems'
+require 'beanstalk-client'
+
+@queue = Beanstalk::Pool.new(['localhost:11300'])
+
+num_jobs = 20
+
+(0...num_jobs).each do |id|
+  job = "Job#{id}"
+  @queue.put job
+end

data/examples/sampled/config/environment.rb

@@ -9,6 +9,8 @@ Raemon::Server.run do |config|
   config.name         = 'Sampled'
   config.worker_klass = 'Sampled::Worker'
   config.num_workers  = 1
+  config.timeout      = 60
+  config.memory_limit = 50 # in MB
   
   config.log_level    = :info
 end

data/examples/sampled/lib/sampled.rb

@@ -4,18 +4,15 @@ module Sampled
     include Raemon::Worker
     
     def start
-      logger.info "Start .. #{Process.ppid}:#{Process.pid}"
+      logger.info "=> Starting worker #{Process.pid}"
     end
 
     def stop
       logger.info "=> Stopping worker #{Process.pid}"
-      exit
     end
 
-    def execute
+    def run
       loop do
-        stop if shutting_down?
-
         logger.warn "I'm executing .. #{Process.ppid}:#{Process.pid}"
         sleep 2
       end

data/examples/test.rb

@@ -12,18 +12,25 @@ class Test
 
   def stop
     logger.info "=> Stopping worker #{Process.pid}"
-    exit
   end
 
-  def execute
-    loop do
-      stop if shutting_down?
+  def run
+    x = 0
     
-      logger.warn "I'm executing .. #{Process.ppid}:#{Process.pid}"
-      sleep 2
+    loop do
+      logger.warn "I'm executing #{x}.. #{Process.ppid}:#{Process.pid}"
+      
+      if x < 3
+        sleep 2
+      else
+        sleep 6
+      end
+      
+      heartbeat!
+      
+      x += 1
     end
   end
-
 end
 
-Raemon::Master.startup 3, Test
+Raemon::Master.start 2, Test, :timeout => 5

data/lib/raemon/master.rb

@@ -1,78 +1,413 @@
 module Raemon
   class Master
-    attr_reader :worker_pids
-    attr_reader :worker_klass
-    attr_reader :logger
+    WORKERS = {}
+
+    SELF_PIPE = []
+
+    SIG_QUEUE = []
+
+    CHUNK_SIZE = (16*1024)
     
-    def self.startup(num_workers, worker_klass, opts={})
-      master = new(opts)
-      master.startup(num_workers, worker_klass)
+    attr_accessor :name, :num_workers, :worker_klass,
+                  :master_pid, :pid_file,
+                  :logger, :timeout, :memory_limit
+    
+    def self.start(num_workers, worker_klass, options={})
+      master = new(options)
+      master.start(num_workers, worker_klass)
     end
     
-    def self.shutdown(pid_file)
-      pid = File.open(pid_file, 'r') {|f| f.gets }.to_i
-      Process.kill('TERM', pid) if pid > 0
-      File.unlink(pid_file)
+    def self.stop(options={})
+      pid_file = options[:pid_file]
+      pid = options[:pid] || (File.read(pid_file).to_i rescue 0)
+      Process.kill('QUIT', pid) if pid > 0
     rescue Errno::ESRCH
     end
     
-    def initialize(opts={})
-      @detach         = opts[:detach] || false
-      @logger         = opts[:logger] || Logger.new(STDOUT)
-      @pid_file       = opts[:pid_file]
-      @worker_pids    = []
+    def initialize(options={})
+      @detach         = options[:detach] || false
+      @name           = options[:name] || 'Raemon'
+      @pid_file       = options[:pid_file]
+      @logger         = options[:logger] || Logger.new(STDOUT)
+      @timeout        = options[:timeout] || 180 # 3 minutes
+      @memory_limit   = options[:memory_limit] # in MB
       
       daemonize if @detach
     end
     
-    def startup(num_workers, worker_klass)
-      logger.info "=> Starting Raemon::Master with #{num_workers} worker(s)"
-      
+    def start(num_workers, worker_klass)
+      logger.info "=> Starting #{name} with #{num_workers} worker(s)"
+
+      @master_pid   = $$
+      @num_workers  = num_workers
       @worker_klass = worker_klass
       
-      # Check if the worker implements our protocol
+      # Check if the worker implements our interface
       if !worker_klass.include?(Raemon::Worker)
         logger.error "** Invalid Raemon worker"
+        logger.close
         exit
       end
       
-      # Spawn workers
-      num_workers.times { worker_pids << worker_klass.start!(self) }
-      
-      # Setup signals for the master process
-      setup_signals
-      
-      # Wait for all the workers
-      Process.waitall
-      
-      logger.close
+      # Start the master loop which spawns and monitors workers
+      master_loop!
     end
     
-    def shutdown
-      @worker_pids.each { |wpid| worker_klass.stop!(wpid) }
+    # Terminates all workers, but does not exit master process
+    def stop(graceful=true)
+      kill_each_worker(graceful ? :QUIT : :TERM)
+      timeleft = timeout
+      step = 0.2
+      reap_all_workers
+      until WORKERS.empty?
+        sleep(step)
+        reap_all_workers
+        (timeleft -= step) > 0 and next
+        kill_each_worker(:KILL)
+      end
     end
     
-    def daemonize
-      exit if Process.fork
+    def worker_heartbeat!(worker)
+      return if timeout <= 0
+      @last_pulse ||= 0
       
-      Process.setsid
+      begin
+        if Time.now.to_i > @last_pulse + (timeout/2) 
+          # Pulse (our lifeline to the master process)
+          worker.pulse.chmod(@last_pulse = Time.now.to_i)
+
+          # Make sure master is still around otherwise exit
+          master_pid == Process.ppid or return
+        end
+      rescue => ex
+        if worker.pulse
+          logger.error "Unhandled listen loop exception #{ex.inspect}."
+          logger.error ex.backtrace.join("\n")
+        end
+      end
+    end
     
-      Dir.chdir '/'
-      File.umask 0000
+    
+    private
+        
+      # list of signals we care about and trap in master.
+      QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP, :TTIN, :TTOU ]
+
+
+      # monitors children and receives signals forever
+      # (or until a termination signal is sent).  This handles signals
+      # one-at-a-time time and we'll happily drop signals in case somebody
+      # is signalling us too often.
+      def master_loop!
+        # this pipe is used to wake us up from select(2) in #join when signals
+        # are trapped.  See trap_deferred
+        init_self_pipe!
+        respawn = true
+
+        QUEUE_SIGS.each { |sig| trap_deferred(sig) }
+        trap(:CHLD) { |sig_nr| awaken_master }
+        
+        process_name 'master'
+        logger.info "master process ready"
+        
+        # Spawn workers for the first time
+        maintain_worker_count
+        
+        begin
+          loop do
+            monitor_memory_usage
+            reap_all_workers
 
-      STDIN.reopen '/dev/null'
-      STDOUT.reopen '/dev/null', 'a'
-      STDERR.reopen '/dev/null', 'a'
+            case SIG_QUEUE.shift
+            when nil
+              murder_lazy_workers
+              maintain_worker_count if respawn
+              master_sleep
+            when :QUIT # graceful shutdown
+              break
+            when :TERM, :INT # immediate shutdown
+              stop(false)
+              break
+            when :USR1
+              kill_each_worker(:USR1)
+            when :USR2
+              kill_each_worker(:USR2)
+            when :WINCH
+              if Process.ppid == 1 || Process.getpgrp != $$
+                respawn = false
+                logger.info "gracefully stopping all workers"
+                kill_each_worker(:QUIT)
+              else
+                logger.info "SIGWINCH ignored because we're not daemonized"
+              end
+            when :TTIN
+              @num_workers += 1
+            when :TTOU
+              @num_workers -= 1 if @num_workers > 0
+            when :HUP
+              # TODO: should restart the workers, but a :QUIT could stall
+              # respawn = true
+              # kill_each_worker(:QUIT)
+            end
+          end
+        rescue Errno::EINTR
+          retry
+        rescue => ex
+          logger.error "Unhandled master loop exception #{ex.inspect}."
+          logger.error ex.backtrace.join("\n")
+          retry
+        end
+        
+        # Gracefully shutdown all workers on our way out
+        stop
+        logger.info "master complete"
+        
+        # Close resources
+        unlink_pid_safe(pid_file) if pid_file
+        logger.close
+      end
+
+
+      # defer a signal for later processing in #master_loop! (master process)
+      def trap_deferred(signal)
+        trap(signal) do |sig_nr|
+          if SIG_QUEUE.size < 5
+            SIG_QUEUE << signal
+            awaken_master
+          else
+            logger.error "ignoring SIG#{signal}, queue=#{SIG_QUEUE.inspect}"
+          end
+        end
+      end
       
-      File.open(@pid_file, 'w') { |f| f.puts(Process.pid) } if @pid_file
-    end
+      # wait for a signal hander to wake us up and then consume the pipe
+      # Wake up every second anyways to run murder_lazy_workers
+      def master_sleep
+        begin
+          ready = IO.select([SELF_PIPE.first], nil, nil, 1) or return
+          ready.first && ready.first.first or return
+          loop { SELF_PIPE.first.read_nonblock(CHUNK_SIZE) }
+        rescue Errno::EAGAIN, Errno::EINTR
+        end
+      end
     
-    def setup_signals
-      shutdown_block = Proc.new { shutdown }
+      def awaken_master
+        begin
+          SELF_PIPE.last.write_nonblock('.') # wakeup master process from select
+        rescue Errno::EAGAIN, Errno::EINTR
+          # pipe is full, master should wake up anyways
+          retry
+        end
+      end
+
+      # reaps all unreaped workers
+      def reap_all_workers
+        begin
+          loop do
+            wpid, status = Process.waitpid2(-1, Process::WNOHANG)
+            wpid or break
+            worker = WORKERS.delete(wpid) and worker.pulse.close rescue nil
+            logger.info "reaped #{status.inspect} " \
+                        "worker=#{worker.id rescue 'unknown'}"
+          end
+        rescue Errno::ECHILD
+        end
+      end
+
+      # forcibly terminate all workers that haven't checked in in timeout
+      # seconds.  The timeout is implemented using an unlinked File
+      # shared between the parent process and each worker.  The worker
+      # runs File#chmod to modify the ctime of the File.  If the ctime
+      # is stale for >timeout seconds, then we'll kill the corresponding
+      # worker.
+      def murder_lazy_workers
+        return if timeout <= 0
+        
+        diff = stat = nil
+        
+        WORKERS.dup.each_pair do |wpid, worker|
+          begin
+            stat = worker.pulse.stat
+          rescue => ex
+            logger.warn "worker=#{worker.id} PID:#{wpid} stat error: #{ex.inspect}"
+            kill_worker(:QUIT, wpid)
+            next
+          end
+          stat.mode == 0100000 and next
+          (diff = (Time.now - stat.ctime)) <= timeout and next
+          logger.error "worker=#{worker.id} PID:#{wpid} timeout " \
+                       "(#{diff}s > #{timeout}s), killing"
+          kill_worker(:KILL, wpid) # take no prisoners for timeout violations
+        end
+      end
+
+      # Spawn workers, and initalize new workers if some are
+      # no longer running
+      def spawn_workers
+        (0...num_workers).each do |id|
+          WORKERS.values.include?(id) and next
+          worker = worker_klass.new(self, id, Raemon::Util.tmpio)
+
+          # Fork the worker processes wrapped in the worker loop
+          WORKERS[fork { worker_loop!(worker) }] = worker
+        end
+      end
+
+      def maintain_worker_count
+        off = num_workers - WORKERS.size
+
+        if off.zero?
+          return
+        elsif off == num_workers
+          # None of the workers are running, lets be gentle
+          @spawn_attempts ||= 0
+          sleep 1 if @spawn_attempts > 1
+          if timeout > 0 && @spawn_attempts > timeout
+            # We couldn't get the workers going after timeout
+            # seconds, so let's assume this will never work
+            logger.error "Unable to spawn workers after #{@spawn_attempts} attempts"
+            master_quit
+            return
+          end
+          @spawn_attempts += 1
+        else
+          @spawn_attempts = nil
+        end
+        
+        return spawn_workers if off > 0
+
+        WORKERS.dup.each_pair do |wpid, worker|
+          worker.id >= num_workers && kill_worker(:QUIT, wpid) rescue nil
+        end
+      end
+
+      # gets rid of stuff the worker has no business keeping track of
+      # to free some resources and drops all sig handlers.
+      # traps for USR1, USR2, and HUP may be set in the after_fork Proc
+      # by the user.
+      def init_worker_process(worker)
+        QUEUE_SIGS.each { |sig| trap(sig, nil) }
+        trap(:CHLD, 'DEFAULT')
+        SIG_QUEUE.clear
+        process_name "worker[#{worker.id}]"
+
+        init_self_pipe!        
+        WORKERS.values.each { |other_worker| other_worker.pulse.close rescue nil }
+        WORKERS.clear
+
+        worker.pulse.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        @timeout /= 2.0 # halve it for select
+      end
       
-      trap('INT', shutdown_block)
-      trap('TERM', shutdown_block)
-    end
+      # runs inside each forked worker, this sits around and waits
+      # for connections and doesn't die until the parent dies (or is
+      # given a INT, QUIT, or TERM signal)
+      def worker_loop!(worker)
+        init_worker_process(worker)
+
+        # Graceful shutdown
+        trap(:QUIT) do
+          worker.stop if worker.respond_to?(:stop)
+          exit!(0)
+        end
+        
+        # Immediate termination
+        [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } }
+        
+        # Worker start
+        logger.info "worker=#{worker.id} ready"
+        worker.start if worker.respond_to?(:start)
+        
+        # Worker run loop
+        worker.run
+      end
+      
+      # delivers a signal to a worker and fails gracefully if the worker
+      # is no longer running.
+      def kill_worker(signal, wpid)
+        begin
+          Process.kill(signal, wpid)
+        rescue Errno::ESRCH
+          worker = WORKERS.delete(wpid) and worker.pulse.close rescue nil
+        end
+      end
+
+      # delivers a signal to each worker
+      def kill_each_worker(signal)
+        WORKERS.keys.each { |wpid| kill_worker(signal, wpid) }
+      end
+
+      # Make the master quit
+      def master_quit
+        SIG_QUEUE << :QUIT
+      end
+
+      # unlinks a PID file at given +path+ if it contains the current PID
+      # still potentially racy without locking the directory (which is
+      # non-portable and may interact badly with other programs), but the
+      # window for hitting the race condition is small
+      def unlink_pid_safe(path)
+        (File.read(path).to_i == $$ and File.unlink(path)) rescue nil
+      end
+
+      # returns a PID if a given path contains a non-stale PID file,
+      # nil otherwise.
+      def valid_pid?(path)
+        wpid = File.read(path).to_i
+        wpid <= 0 and return
+        begin
+          Process.kill(0, wpid) # send null signal to check if its alive
+          return wpid
+        rescue Errno::ESRCH
+          # don't unlink stale pid files, racy without non-portable locking...
+        end
+        rescue Errno::ENOENT
+      end
+
+      def process_name(tag)
+        $0 = "#{name} #{tag}"
+      end
+
+      def init_self_pipe!
+        SELF_PIPE.each { |io| io.close rescue nil }
+        SELF_PIPE.replace(IO.pipe)
+        SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+      end
+
+      def daemonize
+        exit if Process.fork
+      
+        Process.setsid
+    
+        Dir.chdir '/'
+        File.umask 0000
+
+        STDIN.reopen '/dev/null'
+        STDOUT.reopen '/dev/null', 'a'
+        STDERR.reopen '/dev/null', 'a'
+      
+        File.open(pid_file, 'w') { |f| f.puts(Process.pid) } if pid_file
+      end
+      
+      # Check memory usage every 60 seconds if a memory limit is enforced
+      def monitor_memory_usage
+        return if memory_limit.nil?
+        @last_memory_chk ||= 0
+
+        if @last_memory_chk + 60 < Time.now.to_i
+          @last_memory_chk = Time.now.to_i
+          WORKERS.dup.each_pair do |wpid, worker|
+            if memory_usage(wpid) > (memory_limit*1024)
+              logger.warn "memory limit (#{memory_limit}MB) reached by worker=#{worker.id}"
+              kill_worker(:QUIT, wpid)
+            end
+          end
+        end
+      end
+
+      def memory_usage(pid)
+        `ps -o rss= -p #{pid}`.to_i
+      end
     
   end
 end

data/lib/raemon/server.rb

@@ -16,7 +16,7 @@ module Raemon
 
         # Check if the server is already running
         if running?
-          STDERR.puts "Error: #{server_name} is already running."
+          $stderr.puts "Error: #{server_name} is already running."
           exit
         end
 
@@ -25,15 +25,18 @@ module Raemon
         
         worker_klass = instance_eval(config.worker_klass)
         
-        Raemon::Master.startup config.num_workers, worker_klass, {
-          :detach   => config.detach,
-          :logger   => config.logger,
-          :pid_file => pid_file
+        Raemon::Master.start config.num_workers, worker_klass, {
+          :name         => server_name,
+          :pid_file     => pid_file,
+          :detach       => config.detach,
+          :logger       => config.logger,
+          :timeout      => config.timeout,
+          :memory_limit => config.memory_limit
         }
       end
       
       def shutdown!
-        Raemon::Master.shutdown pid_file
+        Raemon::Master.stop :pid_file => pid_file
       end
       
       def console!
@@ -101,13 +104,15 @@ module Raemon
       end
       
       def running?
-        # TODO
-        false
+        pid = File.read(pid_file).to_i rescue 0
+        Process.kill(0, pid) if pid > 0
+      rescue Errno::ESRCH
       end
     end
     
     class Configuration
-      ATTRIBUTES = [ :name, :detach, :worker_klass, :num_workers, :log_level, :logger ]
+      ATTRIBUTES = [ :name, :detach, :num_workers, :worker_klass,
+                     :log_level, :logger, :timeout, :memory_limit ]
 
       attr_accessor *ATTRIBUTES
       

data/lib/raemon/util.rb

@@ -0,0 +1,23 @@
+module Raemon
+  class Util
+    class << self
+      
+      # Creates and returns a new File object.  The File is unlinked
+      # immediately, switched to binary mode, and userspace output
+      # buffering is disabled. Method pulled from Unicorn library.
+      def tmpio
+        begin
+          fp = File.open("#{Dir::tmpdir}/#{rand}",
+                          File::RDWR | File::CREAT | File::EXCL, 0600)
+        rescue Errno::EEXIST
+          retry
+        end
+        File.unlink(fp.path)
+        fp.binmode
+        fp.sync = true
+        fp
+      end
+      
+    end
+  end
+end

data/lib/raemon/worker.rb

@@ -2,52 +2,32 @@ module Raemon
   module Worker
     
     def self.included(base)
-      base.send :extend, ClassMethods
       base.send :include, InstanceMethods
     end
     
-    module ClassMethods
-      def start!(master=nil)
-        child_pid = Process.fork do
-          # Child process
-          worker = new(master)
-          worker.execute
-        end
-        
-        # Parent returns the worker's pid
-        return child_pid
-      end
-    
-      def stop!(worker_pid)
-        Process.kill('QUIT', worker_pid) rescue nil
-      end
-    end
-    
     module InstanceMethods
-      attr_reader :logger
+      attr_reader :master, :logger, :id, :pid, :pulse
       
-      def initialize(master=nil)
+      def initialize(master, id, pulse)
         @master = master
-        @logger = master.logger if master
-        
-        setup_signals
-        start
+        @logger = master.logger
+        @id     = id
+        @pid    = $$
+        @pulse  = pulse
       end
-        
-      def start;                                      end
-      def stop;                                       end
-      def shutting_down?;   @shutting_down;           end
-      def execute;          raise "Abstract method";  end
-
-      def setup_signals
-        quit_block = Proc.new { @shutting_down = true }
-        force_quit_block = Proc.new { exit }
-
-        trap('QUIT', quit_block)
-        trap('TERM', force_quit_block)
-        trap('INT') {} # Reset INT signal handler
+      
+      def ==(other_id)
+        @id == other_id
+      end
+      
+      def run
+        raise "Abstract method"
+      end
+      
+      def heartbeat!
+        master.worker_heartbeat!(self)
       end
     end
-    
+        
   end
 end

data/lib/raemon.rb

@@ -1,10 +1,12 @@
-require 'socket'
+require 'fcntl'
+require 'tmpdir'
 require 'logger'
 
 module Raemon
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
+  
+  autoload :Master, 'raemon/master'
+  autoload :Worker, 'raemon/worker'
+  autoload :Server, 'raemon/server'
+  autoload :Util,   'raemon/util'
 end
-
-require 'raemon/server'
-require 'raemon/master'
-require 'raemon/worker'

data/raemon.gemspec

@@ -0,0 +1,78 @@
+# 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{raemon}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Peter Kieltyka"]
+  s.date = %q{2010-03-15}
+  s.description = %q{Raemon is a Ruby framework for building UNIX daemons.}
+  s.email = %q{peter.kieltyka@nulayer.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "examples/beanstalk.rb",
+     "examples/evented.rb",
+     "examples/queue.rb",
+     "examples/sampled/bin/sampled",
+     "examples/sampled/config/boot.rb",
+     "examples/sampled/config/environment.rb",
+     "examples/sampled/config/environments/development.rb",
+     "examples/sampled/config/environments/production.rb",
+     "examples/sampled/config/environments/test.rb",
+     "examples/sampled/config/initializers/settings.rb",
+     "examples/sampled/config/settings.yml",
+     "examples/sampled/lib/sampled.rb",
+     "examples/sampled/log/.keep",
+     "examples/sampled/test/.keep",
+     "examples/sampled/tmp/pids/.keep",
+     "examples/sampled/vendor/.keep",
+     "examples/test.rb",
+     "lib/raemon.rb",
+     "lib/raemon/master.rb",
+     "lib/raemon/server.rb",
+     "lib/raemon/util.rb",
+     "lib/raemon/worker.rb",
+     "raemon.gemspec"
+  ]
+  s.homepage = %q{http://github.com/pkieltyka/raemon}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Raemon is a Ruby framework for building UNIX daemons.}
+  s.test_files = [
+    "examples/beanstalk.rb",
+     "examples/evented.rb",
+     "examples/queue.rb",
+     "examples/sampled/config/boot.rb",
+     "examples/sampled/config/environment.rb",
+     "examples/sampled/config/environments/development.rb",
+     "examples/sampled/config/environments/production.rb",
+     "examples/sampled/config/environments/test.rb",
+     "examples/sampled/config/initializers/settings.rb",
+     "examples/sampled/lib/sampled.rb",
+     "examples/test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: raemon
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Peter Kieltyka
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-01 00:00:00 -05:00
+date: 2010-03-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +35,7 @@ files:
 - VERSION
 - examples/beanstalk.rb
 - examples/evented.rb
+- examples/queue.rb
 - examples/sampled/bin/sampled
 - examples/sampled/config/boot.rb
 - examples/sampled/config/environment.rb
@@ -39,6 +45,7 @@ files:
 - examples/sampled/config/initializers/settings.rb
 - examples/sampled/config/settings.yml
 - examples/sampled/lib/sampled.rb
+- examples/sampled/log/.keep
 - examples/sampled/test/.keep
 - examples/sampled/tmp/pids/.keep
 - examples/sampled/vendor/.keep
@@ -46,7 +53,9 @@ files:
 - lib/raemon.rb
 - lib/raemon/master.rb
 - lib/raemon/server.rb
+- lib/raemon/util.rb
 - lib/raemon/worker.rb
+- raemon.gemspec
 has_rdoc: true
 homepage: http://github.com/pkieltyka/raemon
 licenses: []
@@ -60,24 +69,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Raemon is a Ruby framework for building UNIX daemons.
 test_files: 
 - examples/beanstalk.rb
 - examples/evented.rb
+- examples/queue.rb
 - examples/sampled/config/boot.rb
 - examples/sampled/config/environment.rb
 - examples/sampled/config/environments/development.rb
@@ -85,6 +97,4 @@ test_files:
 - examples/sampled/config/environments/test.rb
 - examples/sampled/config/initializers/settings.rb
 - examples/sampled/lib/sampled.rb
-- examples/sampled/test/example_test.rb
-- examples/sampled/test/test_helper.rb
 - examples/test.rb

data/examples/sampled/test/example_test.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class ExampleTest < Test::Unit::TestCase
-
-  def test_nothing
-    assert true
-    
-    assert defined? Sampled::Worker
-  end
-
-end

data/examples/sampled/test/test_helper.rb

@@ -1,7 +0,0 @@
-ENV['RAEMON_ENV'] = 'test'
-
-# Add any libs you need for your test suite here
-require 'rubygems'
-
-require File.dirname(__FILE__) + '/../config/environment'
-Raemon::Server.startup!