raad 0.3.1 → 0.3.3

data/CHANGELOG.md

@@ -1,2 +1,8 @@
 # 0.3.1, 08-24-2011
-- initial release. support for MRI 1.8 & 1.9 only
+- initial release. support for MRI 1.8 & 1.9 only
+
+# 0.3.3, 08-26-2011
+- reworked runner stop sequence & signals trapping
+- force kill + pid removal bug
+- wrong exit code bug
+- comments & cosmetics

data/README.md

@@ -1,13 +1,25 @@
-# Raad v0.3.1
+# Raad v0.3.3
 
-Raad - Ruby as a Daemon lightweight service wrapper.
+Raad - Ruby as a daemon lightweight service wrapper.
 
 Raad is a non-intrusive, lightweight, simple Ruby daemon maker. Basically A simple class which implements
-the start and stop methods, can be used seemslessy as a daemon or a normal console app.
+the start and stop methods, can be used seamlessly as a daemon or a normal console app.
 
 Raad provides daemon control using the start/stop commands. Your code can optionnally use the Raad
 logging module. 
 
+## Installation
+
+### Gem
+gem install raad
+
+### Bundler
+#### Latest from github
+gem "raad", :git => "git://github.com/praized/raad.git", :branch => "master"
+
+#### Released gem
+gem "raad", "~> 0.3.3"
+
 ## Example
 Create a class with a start and a stop method. Just by requiring 'raad', your class will be 
 wrapped by Raad and daemonizable.
@@ -82,12 +94,12 @@ The Log4r gem (~> 1.1.9) is required.
 ## Author
 Authored by Colin Surprenant, [@colinsurprenant][twitter], [colin.surprenant@needium.com][needium], [colin.surprenant@gmail.com][gmail], [http://github.com/colinsurprenant][github]
 
-## Acknoledgements
+## Acknowledgements
 Thanks to the Thin ([https://github.com/macournoyer/thin][thin]), Goliath ([https://github.com/postrank-labs/goliath/][goliath]) 
 and Sinatra ([https://github.com/bmizerany/sinatra][sinatra]) projects for providing inspiration and/or code!
 
 ## License
-Raada is distributed under the Apache License, Version 2.0. See the LICENSE.md file.
+Raad is distributed under the Apache License, Version 2.0. See the LICENSE.md file.
 
 [needium]: colin.surprenant@needium.com
 [gmail]: colin.surprenant@gmail.com

data/lib/raad/runner.rb

@@ -1,5 +1,6 @@
 require 'optparse'
 require 'thread'
+require 'monitor'
 
 module Raad
   class Runner
@@ -9,54 +10,46 @@ module Raad
     SOFT_STOP_TIMEOUT = 58 * SECOND
     HARD_STOP_TIMEOUT = 60 * SECOND
 
-    # The pid file for the server
-    # @return [String] The file to write the servers pid file into
-    attr_accessor :pid_file
-
-    # The application
-    # @return [Object] The service to execute
-    attr_accessor :service
-
-    # The parsed options
-    # @return [Hash] The options parsed by the runner
-    attr_reader :options
+    attr_accessor :service, :pid_file, :options
 
     # Create a new Runner
     #
-    # @param argv [Array] The command line arguments
-    # @param service [Object] The service to execute
+    # @param argv [Array] command line arguments
+    # @param service [Object] service to execute
     def initialize(argv, service)
       create_options_parser(service).parse!(argv)
 
-      options[:command] = argv[0].to_s.downcase
+      # start/stop 
+      @options[:command] = argv[0].to_s.downcase
       unless ['start', 'stop'].include?(options[:command])
         puts(">> start|stop command is required")
-        exit!
+        exit!(false)
       end
 
       @service = service
       @service_name = nil
       @logger_options = nil
       @pid_file = nil
-      @service_thread = nil
-      @stopped = false
+
+      # signals handling
+      @signals = []
+      @monitor = Monitor.new
+      @stop_signaled = false
     end
 
     def run
       # first load config if present
       Configuration.load(options[:config] || File.expand_path("./config/#{default_service_name}.rb"))
 
-      # then set vars which depends on configuration
+      # settings which depends on configuration
       @service_name = options[:name] || Configuration.daemon_name || default_service_name
 
-      # ajust "dynamic defaults"
       unless options[:log_file]
         options[:log_file] = (options[:daemonize] ? File.expand_path("#{@service_name}.log") : nil)
       end
       unless options[:log_stdout]
         options[:log_stdout] = !options[:daemonize]
       end
-
       @logger_options = {
         :file => options.delete(:log_file),
         :stdout => options.delete(:log_stdout),
@@ -64,15 +57,17 @@ module Raad
       }
       @pid_file = options.delete(:pid_file) || "./#{@service_name}.pid"
 
+      # check for stop command, @pid_file must be set
+      if options[:command] == 'stop'
+        puts(">> Raad service wrapper v#{VERSION} stopping")
+        success = send_signal('TERM', HARD_STOP_TIMEOUT) # if not stopped afer HARD_STOP_TIMEOUT, SIGKILL will be sent
+        exit!(success)
+      end
+
       # setup logging
       Logger.setup(@logger_options)
       Logger.level = Configuration.log_level if Configuration.log_level
 
-      if options[:command] == 'stop'
-        puts(">> Raad service wrapper v#{VERSION} stopping")
-        send_signal('TERM', HARD_STOP_TIMEOUT) # if not stopped afer HARD_STOP_TIMEOUT, SIGKILL will be sent
-        exit!
-      end
       puts(">> Raad service wrapper v#{VERSION} starting")
 
       Dir.chdir(File.expand_path(File.dirname("./"))) unless Raad.test?
@@ -85,6 +80,87 @@ module Raad
 
     private
 
+    # Run the service
+    #
+    # @return nil
+    def run_service
+      Logger.info("starting #{@service_name} service in #{Raad.env.to_s} mode")
+
+      at_exit do
+        Logger.info(">> Raad service wrapper stopped")
+      end
+
+      # store received signals into the @signal queue. here we want to avoid
+      # doing anything complex from within the trap block. 
+      [:INT, :TERM, :QUIT].each do |sig|
+        trap(sig) {@monitor.synchronize{@signals << :STOP}}
+      end
+
+      # launch the signal handler thread. the idea here is to handle signal outside the 
+      # trap block. the trap block will simply store the signal which this thread will 
+      # retrieve and do whatever is required. 
+      signals_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        loop do
+          signals = @monitor.synchronize{s = @signals.dup; @signals.clear; s}
+
+          if signals.include?(:STOP)
+            @stop_signaled = true
+            stop_service
+            break
+          end
+
+          sleep(0.5)
+        end
+      end
+
+      # launch the service thread and call start. we expect start not to return
+      # unless it is done or has been stopped.
+      service_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        service.start
+        stop_service unless @stop_signaled # don't stop twice if already called from the signals_thread
+      end
+
+      # use exit and not exit! to make sure the at_exit hooks are called, like the pid cleanup, etc.
+      exit(wait_or_kill(service_thread))
+    end
+
+    def stop_service
+      Logger.info("stopping #{@service_name} service")
+      service.stop if service.respond_to?(:stop)
+    end
+
+    # try to do a timeout join periodically on the given thread. if the join succeed then the stop
+    # sequence is successful and return true.
+    # Otherwise, on timeout if stop has beed signaled, wait a maximum of SOFT_STOP_TIMEOUT on the
+    # thread and kill it if the timeout is reached and return false in that case.
+    #
+    # @return [Boolean] true if the thread normally terminated, false if a kill was necessary
+    def wait_or_kill(thread)
+      while thread.join(SECOND).nil?
+        # the join has timed out, thread is still buzzy.
+        if @stop_signaled
+          # but if stop has been signalled, start "the final countdown" ♫
+          try = 0; join = nil
+          while (try += 1) <= SOFT_STOP_TIMEOUT && join.nil? do
+            join = thread.join(SECOND)
+            Logger.debug("waiting for service to stop #{try}/#{SOFT_STOP_TIMEOUT}") if join.nil?
+          end
+          if join.nil?
+            Logger.error("stop timeout exhausted, killing service thread")
+            thread.kill
+            return false
+          end
+          return true
+        end
+      end
+      true
+    end
+
+    # convert the service class name from CameCase to underscore
+    #
+    # @return [String] underscored service class name
     def default_service_name
       service.class.to_s.split('::').last.gsub(/(.)([A-Z])/,'\1_\2').downcase!
     end
@@ -121,64 +197,12 @@ module Raad
       service.respond_to?(:options_parser) ? service.options_parser(options_parser) : options_parser
     end
 
-    # Output the servers options
+    # Output the servers options and exit Ruby
     #
     # @param opts [OptionsParser] The options parser
-    # @return [exit] This will exit Ruby
     def show_options(opts)
       puts(opts)
-      exit!
-    end
-
-    # Run the server
-    #
-    # @return [Nil]
-    def run_service
-      Logger.info("starting #{@service_name} service in #{Raad.env.to_s} mode")
-
-      at_exit do
-        Logger.info(">> Raad service wrapper stopped")
-      end
-
-      # by default exit on SIGTERM and SIGINT
-      [:INT, :TERM, :QUIT].each do |sig|
-        trap(sig) {stop_service}
-      end
-
-      @service_thread = Thread.new do
-        Thread.current.abort_on_exception = true
-        service.start
-      end
-      while @service_thread.join(SECOND).nil?
-        if @stopped
-          Logger.info("stopping #{@service_name} service")
-          service.stop if service.respond_to?(:stop)
-          wait_or_kill_service
-          return
-        end
-      end
-
-      unless @stopped
-        Logger.info("stopping #{@service_name} service")
-        service.stop if service.respond_to?(:stop)
-      end
-    end
-
-    def stop_service
-      @stopped = true
-    end
-
-    def wait_or_kill_service
-      try = 0; join = nil
-      while (try += 1) <= SOFT_STOP_TIMEOUT && join.nil? do
-        join = @service_thread.join(SECOND)
-        Logger.debug("waiting for service to stop #{try}/#{SOFT_STOP_TIMEOUT}") if join.nil?
-      end
-      if join.nil?
-        Logger.error("stop timeout exhausted, killing service thread")
-        @service_thread.kill
-        @service_thread.join
-      end
+      exit!(false)
     end
      
   end

data/lib/raad/unix_daemon.rb

@@ -58,25 +58,36 @@ module Daemonizable
       Timeout.timeout(timeout) do
         sleep 0.1 while Process.running?(pid)
       end
+      true
     else
       puts(">> can't stop process, no pid found in #{@pid_file}")
+      false
     end
   rescue Timeout::Error
-    force_kill
+    force_kill_and_remove_pid_file
   rescue Interrupt
-    force_kill
+    force_kill_and_remove_pid_file
   rescue Errno::ESRCH # No such process
-    force_kill
+    puts(">> can't stop process, no such process #{pid}")
+    remove_pid_file
+    false
   end
   
-  def force_kill
-    if pid = read_pid_file
+  def force_kill_and_remove_pid_file
+    success = if (pid = read_pid_file)
       puts(">> sending KILL signal to process #{pid}")
       Process.kill("KILL", pid)
-      File.delete(@pid_file) if File.exist?(@pid_file)
+      true
     else
       puts(">> can't stop process, no pid found in #{@pid_file}")
+      false
     end
+    remove_pid_file
+    success
+  rescue Errno::ESRCH # No such process
+    puts(">> can't stop process, no such process #{pid}")
+    remove_pid_file
+    false
   end
   
   def read_pid_file

data/lib/raad/version.rb

@@ -1,3 +1,3 @@
 module Raad
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end unless defined?(Raad::VERSION)

metadata

@@ -2,7 +2,7 @@
 name: raad
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors: 
 - Colin Surprenant
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-24 00:00:00 Z
+date: 2011-08-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubyforge