camping-picnic - Project Hosting on Google Code

Earlier this year Jul 21, 2009 PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page commented on by shane.swartz - The service_control.rb file has some TODO's in it that I've completed in order to allow the rubycas-server rubycas-server-ctl script to work. Here is the updated service_control.rb file: require 'optparse' module Picnic # Provides functionality for controlling a Picnic-based server as # an init.d service. # # Based on code from rubycas-server by jzylks and matt.zukowski. # # Usage Example: # # #!/usr/bin/env ruby # # require 'rubygems' # require 'picnic/service_control' # # ctl = Picnic::ServiceControl.new('foo') # ctl.handle_cli_input # # The file containing this code can now be used to control the Picnic # app 'foo'. # # For, example, lets say you put this in a file called <tt>foo-ctl</tt>. # You can now use <tt>foo-ctl</tt> on the command line as follows: # # chmod +x foo-ctl # ./foo-ctl -h # ./foo-ctl start --verbose --config /etc/foo/config.yml # ./foo-ctl stop --config /etc/foo/config.yml # # Your <tt>foo-ctl</tt> script can also be used as part of Linux's init.d # mechanism for launching system services. To do this, create the file # <tt>/etc/init.d/foo</tt> and make sure that it is executable. It will # look something like the following (this may vary depending on your Linux # distribution; this example is for SuSE): # # #!/bin/sh # CTL=foo-ctl # . /etc/rc.status # # rc_reset # case "$1" in # start) # $CTL start # rc_status -v # ;; # stop) # $CTL stop # rc_status -v # ;; # restart) # $0 stop # $0 start # rc_status # ;; # status) # $CTL status # rc_status -v # ;; # ) # echo "Usage: $0 {start\|stop\|status\|restart} # exit 1 # ;; # esac # rc_exit # # You should now be able to launch your application like any other init.d script # (just make sure that <tt>foo-ctl</tt> is installed in your executable <tt>PATH</tt> # -- if your application is properly installed as a RubyGem, this will be done automatically). # # On most Linux systems, you can make your app start up automatically during boot by calling: # # chkconfig -a foo # # On Debian and Ubuntu, it's: # # update-rc.d foo defaults # class ServiceControl attr_accessor :app, :options # Creates a new service controller. # # +app+:: The name of the application. This should match the name of the # binary, which by default is expected to be in the same directory # as the service control script. # +options+:: A hash overriding default options. The options are: # +bin_file+:: The name of the binary file that this control # script will use to start and stop your app. # +pid_file+:: Where the app's PID file (containing the app's # process ID) should be placed. # +verbose+:: True if the service control script should report # everything that it's doing to STDOUT. def initialize(app, options = {}) @app = app @options = options @options[:bin_file] \|\|= "bin/#{app}" @options[:pid_file] \|\|= "/etc/#{app}/#{app}.pid" @options[:conf_file] \|\|= nil @options[:verbose] \|\|= false @options = options end # Parses command line options given to the service control script. def handle_cli_input OptionParser.new do \|opts\| opts.banner = "Usage: #{$0} (start\|stop\|restart) [options]" opts.banner += "\n#{app} is only usable when using webrick or mongrel" opts.on("-c", "--config FILE", "Path to #{app} configuration file") { \|value\| @options[:conf_file] = value } opts.on("-P", "--pid_file FILE", "Path to #{app} pid file") { \|value\| @options[:pid_file] = value } opts.on('-v', '--verbose', "Print debugging information to the console") { \|value\| @options[:verbose] = value } if ARGV.empty? puts opts exit else @cmd = opts.parse!(ARGV) if @cmd.nil? puts opts exit end end end if !@options[:conf_file].nil? && !File.exists?(@options[:conf_file]) puts "Invalid path to #{app} configuration file: #{@options[:conf_file]}" exit end case @cmd[0] when "start": puts "Starting #{app}..." start when "stop": puts "Stopping #{app}..." stop when "restart": puts "Restarting #{app}..." stop start when "status": puts "Checking status of #{app}..." status else puts "Invalid command. Usage: #{app}-ctl [-cPv] start\|stop\|restart\|status" end exit end def start # use local app bin if it exists and is executable -- makes debugging easier bin = options[:bin_file] if File.exists?(bin) exec = "ruby #{bin}" else exec = app end case get_state when :ok $stderr.puts "#{app} is already running" exit 1 when :not_running_pid, :empty_pid $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " The pid file will be automatically deleted for you, but this shouldn't have happened!" File.delete(@options[:pid_file]) when :dead $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " Please delete the pid file first." exit 1 when :running_missing_pid $stderr.puts "#{app} is already running (pid file is missing)." exit 1 when :not_running_no_pid # we should be good to go else $stderr.puts "#{app} could not be started. Try looking in the log file for more info." exit 1 end cmd = "#{exec} -d -P #{@options[:pid_file]}" cmd += " -c #{@options[:conf_file]}" if !@options[:conf_file].nil? puts "<<< #{cmd}" if @options[:verbose] output = `#{cmd}` puts ">>> #{output}" if @options[:verbose] sleep (1) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :ok exit 0 else $stderr.puts "\n#{app} could not start properly!\nTry running with the --verbose option for details." case s when :running_missing_pid exit 2 when :not_running_no_pid exit 4 when :not_running_pid exit 3 when :dead exit 1 else exit 4 end end end def stop killSigs = ['TERM','SYS', 'QUIT', 'KILL'] if File.exists? @options[:pid_file] pid = open(@options[:pid_file]).read.to_i for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else pid=`pgrep #{app}` pid.chomp! puts ">>> Stopping with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid.to_i) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else $stderr.puts "#{app} is already stopped." exit 4 end end end def status s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] case s when :ok puts "#{app} appears to be up and running." exit 0 when :not_running_pid $stderr.puts "#{app} does not appear to be running (pid file exists)." exit 3 when :empty_pid $stderr.puts "#{app} does not appear to be running (pid file exists but is empty)." when :not_running_no_pid $stderr.puts "#{app} is not running." exit 1 when :running_missing_pid $stderr.puts "#{app} is running (pid file is missing)." exit 1 when :dead $stderr.puts "#{app} is dead or unresponsive." exit 102 end end def get_state # FIXME: This is a poor attempt at trying to fix a problem where occassionally # an empty pid_file is read, probably because it has not yet been # fully written. sleep 0.5 if File.exists? @options[:pid_file] pid = File.read(@options[:pid_file]).strip puts ">>> Getting state with pid file: #{pid}" if options[:verbose] return :empty_pid unless pid and !pid.empty? # pid file exists but is empty # # Changed 'state=' to 's=' so that this works on Solaris # # The following line modified by Shane Swartz # state = `ps -p #{pid} -o state=`.strip state = `ps -p #{pid} -o s=`.strip puts ">>> pid file: #{pid} - state: #{state}" if options[:verbose] if state == '' return :not_running_pid elsif state == 'O' \|\| state == 'R' \|\| state == 'S' return :ok else return :dead end else # TODO: scan through the process table to see if server is running without pid file # The following code added by Shane Swartz pid=`pgrep #{app}` pid.chomp! puts ">>> Getting state with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? state = `ps -p #{pid} -o s=`.strip puts ">>> No pid file - state: #{state}" if options[:verbose] if state == '' return :not_running_no_pid elsif state == 'O' \|\| state == 'R' \|\| state == 'S' return :running_missing_pid else return :dead end else return :not_running_no_pid end end end end end The service_control.rb file has some TODO's in it that I've completed in order to allow the rubycas-server rubycas-server-ctl script to work. Here is the updated service_control.rb file: require 'optparse' module Picnic # Provides functionality for controlling a Picnic-based server as # an init.d service. # # Based on code from rubycas-server by jzylks and matt.zukowski. # # Usage Example: # # #!/usr/bin/env ruby # # require 'rubygems' # require 'picnic/service_control' # # ctl = Picnic::ServiceControl.new('foo') # ctl.handle_cli_input # # The file containing this code can now be used to control the Picnic # app 'foo'. # # For, example, lets say you put this in a file called <tt>foo-ctl</tt>. # You can now use <tt>foo-ctl</tt> on the command line as follows: # # chmod +x foo-ctl # ./foo-ctl -h # ./foo-ctl start --verbose --config /etc/foo/config.yml # ./foo-ctl stop --config /etc/foo/config.yml # # Your <tt>foo-ctl</tt> script can also be used as part of Linux's init.d # mechanism for launching system services. To do this, create the file # <tt>/etc/init.d/foo</tt> and make sure that it is executable. It will # look something like the following (this may vary depending on your Linux # distribution; this example is for SuSE): # # #!/bin/sh # CTL=foo-ctl # . /etc/rc.status # # rc_reset # case "$1" in # start) # $CTL start # rc_status -v # ;; # stop) # $CTL stop # rc_status -v # ;; # restart) # $0 stop # $0 start # rc_status # ;; # status) # $CTL status # rc_status -v # ;; # ) # echo "Usage: $0 {start\|stop\|status\|restart} # exit 1 # ;; # esac # rc_exit # # You should now be able to launch your application like any other init.d script # (just make sure that <tt>foo-ctl</tt> is installed in your executable <tt>PATH</tt> # -- if your application is properly installed as a RubyGem, this will be done automatically). # # On most Linux systems, you can make your app start up automatically during boot by calling: # # chkconfig -a foo # # On Debian and Ubuntu, it's: # # update-rc.d foo defaults # class ServiceControl attr_accessor :app, :options # Creates a new service controller. # # +app+:: The name of the application. This should match the name of the # binary, which by default is expected to be in the same directory # as the service control script. # +options+:: A hash overriding default options. The options are: # +bin_file+:: The name of the binary file that this control # script will use to start and stop your app. # +pid_file+:: Where the app's PID file (containing the app's # process ID) should be placed. # +verbose+:: True if the service control script should report # everything that it's doing to STDOUT. def initialize(app, options = {}) @app = app @options = options @options[:bin_file] \|\|= "bin/#{app}" @options[:pid_file] \|\|= "/etc/#{app}/#{app}.pid" @options[:conf_file] \|\|= nil @options[:verbose] \|\|= false @options = options end # Parses command line options given to the service control script. def handle_cli_input OptionParser.new do \|opts\| opts.banner = "Usage: #{$0} (start\|stop\|restart) [options]" opts.banner += "\n#{app} is only usable when using webrick or mongrel" opts.on("-c", "--config FILE", "Path to #{app} configuration file") { \|value\| @options[:conf_file] = value } opts.on("-P", "--pid_file FILE", "Path to #{app} pid file") { \|value\| @options[:pid_file] = value } opts.on('-v', '--verbose', "Print debugging information to the console") { \|value\| @options[:verbose] = value } if ARGV.empty? puts opts exit else @cmd = opts.parse!(ARGV) if @cmd.nil? puts opts exit end end end if !@options[:conf_file].nil? && !File.exists?(@options[:conf_file]) puts "Invalid path to #{app} configuration file: #{@options[:conf_file]}" exit end case @cmd[0] when "start": puts "Starting #{app}..." start when "stop": puts "Stopping #{app}..." stop when "restart": puts "Restarting #{app}..." stop start when "status": puts "Checking status of #{app}..." status else puts "Invalid command. Usage: #{app}-ctl [-cPv] start\|stop\|restart\|status" end exit end def start # use local app bin if it exists and is executable -- makes debugging easier bin = options[:bin_file] if File.exists?(bin) exec = "ruby #{bin}" else exec = app end case get_state when :ok $stderr.puts "#{app} is already running" exit 1 when :not_running_pid, :empty_pid $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " The pid file will be automatically deleted for you, but this shouldn't have happened!" File.delete(@options[:pid_file]) when :dead $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " Please delete the pid file first." exit 1 when :running_missing_pid $stderr.puts "#{app} is already running (pid file is missing)." exit 1 when :not_running_no_pid # we should be good to go else $stderr.puts "#{app} could not be started. Try looking in the log file for more info." exit 1 end cmd = "#{exec} -d -P #{@options[:pid_file]}" cmd += " -c #{@options[:conf_file]}" if !@options[:conf_file].nil? puts "<<< #{cmd}" if @options[:verbose] output = `#{cmd}` puts ">>> #{output}" if @options[:verbose] sleep (1) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :ok exit 0 else $stderr.puts "\n#{app} could not start properly!\nTry running with the --verbose option for details." case s when :running_missing_pid exit 2 when :not_running_no_pid exit 4 when :not_running_pid exit 3 when :dead exit 1 else exit 4 end end end def stop killSigs = ['TERM','SYS', 'QUIT', 'KILL'] if File.exists? @options[:pid_file] pid = open(@options[:pid_file]).read.to_i for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else pid=`pgrep #{app}` pid.chomp! puts ">>> Stopping with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid.to_i) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else $stderr.puts "#{app} is already stopped." exit 4 end end end def status s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] case s when :ok puts "#{app} appears to be up and running." exit 0 when :not_running_pid $stderr.puts "#{app} does not appear to be running (pid file exists)." exit 3 when :empty_pid $stderr.puts "#{app} does not appear to be running (pid file exists but is empty)." when :not_running_no_pid $stderr.puts "#{app} is not running." exit 1 when :running_missing_pid $stderr.puts "#{app} is running (pid file is missing)." exit 1 when :dead $stderr.puts "#{app} is dead or unresponsive." exit 102 end end def get_state # FIXME: This is a poor attempt at trying to fix a problem where occassionally # an empty pid_file is read, probably because it has not yet been # fully written. sleep 0.5 if File.exists? @options[:pid_file] pid = File.read(@options[:pid_file]).strip puts ">>> Getting state with pid file: #{pid}" if options[:verbose] return :empty_pid unless pid and !pid.empty? # pid file exists but is empty # # Changed 'state=' to 's=' so that this works on Solaris # # The following line modified by Shane Swartz # state = `ps -p #{pid} -o state=`.strip state = `ps -p #{pid} -o s=`.strip puts ">>> pid file: #{pid} - state: #{state}" if options[:verbose] if state == '' return :not_running_pid elsif state == 'O' \|\| state == 'R' \|\| state == 'S' return :ok else return :dead end else # TODO: scan through the process table to see if server is running without pid file # The following code added by Shane Swartz pid=`pgrep #{app}` pid.chomp! puts ">>> Getting state with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? state = `ps -p #{pid} -o s=`.strip puts ">>> No pid file - state: #{state}" if options[:verbose] if state == '' return :not_running_no_pid elsif state == 'O' \|\| state == 'R' \|\| state == 'S' return :running_missing_pid else return :dead end else return :not_running_no_pid end end end end end Jul 09, 2009 issue 6 (ps command has incorrect syntax for Solaris in service_contr...) reported by shane.swartz - What steps will reproduce the problem? 1. Try running rubycas-server-ctl start\|stop\|restart\|status on a Solaris system. It fails due to incorrect syntax with the "ps" command. 2. 3. What is the expected output? What do you see instead? Using rubycas-server-ctl should allow one to start/stop/restart/status the rubycas-server. The output seen is that the "ps" command has incorrect syntax. What version of the product are you using? On what operating system? picnic-0.8.1.1 gunark-rubycas-server-0.8.0.20090506 Solaris 10 Please provide any additional information below. I originally posted this problem to the rubycas-server site, but I narrowed the problem down to a single line of code in camping-picnic. The problem is that the line "ps -p #{pid} -o state=" in the file service_control.rb. If you change that line to "ps -p #{pid} -o s=" it will work on both Linux and Solaris. What steps will reproduce the problem? 1. Try running rubycas-server-ctl start\|stop\|restart\|status on a Solaris system. It fails due to incorrect syntax with the "ps" command. 2. 3. What is the expected output? What do you see instead? Using rubycas-server-ctl should allow one to start/stop/restart/status the rubycas-server. The output seen is that the "ps" command has incorrect syntax. What version of the product are you using? On what operating system? picnic-0.8.1.1 gunark-rubycas-server-0.8.0.20090506 Solaris 10 Please provide any additional information below. I originally posted this problem to the rubycas-server site, but I narrowed the problem down to a single line of code in camping-picnic. The problem is that the line "ps -p #{pid} -o state=" in the file service_control.rb. If you change that line to "ps -p #{pid} -o s=" it will work on both Linux and Solaris. May 04, 2009 issue 5 (clean_service_url should remove `&' if there're other params...) commented on by godfat - I am so sorry, this issue should be in rubycas-server, please ignore and delete it, thanks. Sorry again. I am so sorry, this issue should be in rubycas-server, please ignore and delete it, thanks. Sorry again. May 04, 2009 issue 5 (clean_service_url should remove `&' if there're other params...) reported by godfat - Hi, Login with service url contains other query string, e.g. page=123, would cause redirect loop because service url didn't match. One includes a `&' in the end, the other don't. So I thought `clean_service_url' should remove the `&' before `ticket' in the url when `service' url contains other query string, e.g. page=2&ticket=LT-123. Here's my patch. http://github.com/godfat/rubycas-server/commit/1dfd749710185ec56dc4529ec4b6a146b9b0b256 Many thanks! Hi, Login with service url contains other query string, e.g. page=123, would cause redirect loop because service url didn't match. One includes a `&' in the end, the other don't. So I thought `clean_service_url' should remove the `&' before `ticket' in the url when `service' url contains other query string, e.g. page=2&ticket=LT-123. Here's my patch. http://github.com/godfat/rubycas-server/commit/1dfd749710185ec56dc4529ec4b6a146b9b0b256 Many thanks! Mar 18, 2009 PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page edited by matt.zukowski Mar 18, 2009 PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page edited by matt.zukowski Mar 18, 2009 PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page edited by matt.zukowski Mar 18, 2009 PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page edited by matt.zukowski Feb 18, 2009 SCM (Info on how to access Picnic's source code repository.) Wiki page edited by matt.zukowski Feb 18, 2009 SCM (Info on how to access Picnic's source code repository.) Wiki page added by matt.zukowski Feb 12, 2009 r101 (COMPLETE OVERHAUL - switched to Camping 2.0 - use Rack inste...) committed by matt.zukowski - COMPLETE OVERHAUL - switched to Camping 2.0 - use Rack instead of custom postambles for running under various server environments - compatibility with Phusion Passenger COMPLETE OVERHAUL - switched to Camping 2.0 - use Rack instead of custom postambles for running under various server environments - compatibility with Phusion Passenger Older Nov 11, 2008 r100 (fix app path problem in service loader) committed by matt.zukowski - fix app path problem in service loader fix app path problem in service loader Nov 10, 2008 r99 (releasing 0.7.1) committed by matt.zukowski - releasing 0.7.1 releasing 0.7.1 Nov 05, 2008 picnic-0.7.0.98.gem (Beta release of Picnic 7.1) file uploaded by matt.zukowski - Labels: Featured Type-Package OpSys-All Beta Labels: Featured Type-Package OpSys-All Beta Nov 05, 2008 r98 (* Fixed config file loading problems rooted in $APP_PATH inc...) committed by matt.zukowski - * Fixed config file loading problems rooted in $APP_PATH inconsistencies. $APP_PATH is now set to the root of the application installation, rather than the bin or lib subdirectory. * Fixed config file loading problems rooted in $APP_PATH inconsistencies. $APP_PATH is now set to the root of the application installation, rather than the bin or lib subdirectory. Oct 28, 2008 r97 (forgot to update date in History.txt for 0.7.0 release) committed by matt.zukowski - forgot to update date in History.txt for 0.7.0 release forgot to update date in History.txt for 0.7.0 release Oct 28, 2008 r96 (Snapshot of 0.7.0 release.) committed by matt.zukowski - Snapshot of 0.7.0 release. Snapshot of 0.7.0 release. Oct 28, 2008 r95 (Releasing 0.7.0) committed by matt.zukowski - Releasing 0.7.0 Releasing 0.7.0 Oct 22, 2008 r94 (went back to origional require-based loading mechanism... ne...) committed by matt.zukowski - went back to origional require-based loading mechanism... new stuff was causing conflicts with Reststop went back to origional require-based loading mechanism... new stuff was causing conflicts with Reststop Oct 21, 2008 r93 (removed stray debug line) committed by matt.zukowski - removed stray debug line removed stray debug line Oct 16, 2008 r92 (more changes to try to fix activeresource/activerecord loadi...) committed by matt.zukowski - more changes to try to fix activeresource/activerecord loading problems more changes to try to fix activeresource/activerecord loading problems Oct 16, 2008 r91 (* activerecord is no longer a requirement. However you shoul...) committed by matt.zukowski - * activerecord is no longer a requirement. However you should make sure that you take care of loading activerecord in your app if you intend to use Camping's database functionality. * activerecord is no longer a requirement. However you should make sure that you take care of loading activerecord in your app if you intend to use Camping's database functionality. Oct 16, 2008 r90 (switched to development) committed by matt.zukowski - switched to development switched to development Oct 16, 2008 r89 (cli no longer requires active_support) committed by matt.zukowski - cli no longer requires active_support cli no longer requires active_support Oct 08, 2008 r88 (* Can now configure the CLI aspect of an app to respond to a...) committed by matt.zukowski - * Can now configure the CLI aspect of an app to respond to additional command- line flags. This is done by passing a block of OptionParser calls as an :extra_cli_options parameter to the Cli initializer. * Can now configure the CLI aspect of an app to respond to additional command- line flags. This is done by passing a block of OptionParser calls as an :extra_cli_options parameter to the Cli initializer. Sep 26, 2008 r87 (trying to get USR2 to properly restart instead of shutting d...) committed by matt.zukowski - trying to get USR2 to properly restart instead of shutting down when running under mongrel... this now works when the server is running in the foreground but not when daemonized :( trying to get USR2 to properly restart instead of shutting down when running under mongrel... this now works when the server is running in the foreground but not when daemonized :( Sep 26, 2008 r86 (poor attempt at trying to fix a problem where occassionally ...) committed by matt.zukowski - poor attempt at trying to fix a problem where occassionally an empty pid_file is read, probably because it has not yet been fully written. poor attempt at trying to fix a problem where occassionally an empty pid_file is read, probably because it has not yet been fully written. Sep 22, 2008 r85 (added History.txt) committed by matt.zukowski - added History.txt added History.txt Sep 22, 2008 r84 (fixed logging constant problem for mongrel (was only fixed f...) committed by matt.zukowski - fixed logging constant problem for mongrel (was only fixed for webrick before) fixed logging constant problem for mongrel (was only fixed for webrick before) Sep 18, 2008 r83 (snapshot of 0.6.5 release) committed by matt.zukowski - snapshot of 0.6.5 release snapshot of 0.6.5 release Sep 18, 2008 r82 (released as 0.6.5) committed by matt.zukowski - released as 0.6.5 released as 0.6.5 Sep 18, 2008 r81 (one more logging-level fix) committed by matt.zukowski - one more logging-level fix one more logging-level fix Sep 18, 2008 r80 ((hopefully) fixed logger issues (see http://groups.google.co...) committed by matt.zukowski - (hopefully) fixed logger issues (see http://groups.google.com/group/rubycas- server/t/14596f6010845ba3?hl=en) (hopefully) fixed logger issues (see http://groups.google.com/group/rubycas- server/t/14596f6010845ba3?hl=en) Aug 07, 2008 issue 4 (cas authentication) reported by steven.nguyen.le - What steps will reproduce the problem? 1. set taskr to authenticate by cas method 2. start taskr 3. log into taskr by cas authentication What is the expected output? What do you see instead? Expected output should redirect to the CAS Login page then redirect back to the taskr tasks page once authentication has been completed. Instead, I receive the error message: "Internal Server Error private method `split' called for nil:NilClass" What version of the product are you using? On what operating system? picnic-0.6.4 and taskr-0.3.0. Tested using both Windows XP and Ubuntu 8.04 Please provide any additional information below. I think I isolated the problem to line 189 of authentication.rb. I tried commenting out "if st.is_valid?" and instead used "if true", which fixed the problem, but I wasn't sure if doing so skipped validation altogether. What steps will reproduce the problem? 1. set taskr to authenticate by cas method 2. start taskr 3. log into taskr by cas authentication What is the expected output? What do you see instead? Expected output should redirect to the CAS Login page then redirect back to the taskr tasks page once authentication has been completed. Instead, I receive the error message: "Internal Server Error private method `split' called for nil:NilClass" What version of the product are you using? On what operating system? picnic-0.6.4 and taskr-0.3.0. Tested using both Windows XP and Ubuntu 8.04 Please provide any additional information below. I think I isolated the problem to line 189 of authentication.rb. I tried commenting out "if st.is_valid?" and instead used "if true", which fixed the problem, but I wasn't sure if doing so skipped validation altogether.

PicnicTutorial (Step-by-step tutorial describing how to build a Picnic-enabl...) Wiki page commented on by shane.swartz - The service_control.rb file has some TODO's in it that I've completed in order to allow the rubycas-server rubycas-server-ctl script to work. Here is the updated service_control.rb file: require 'optparse' module Picnic # Provides functionality for controlling a Picnic-based server as # an init.d service. # # Based on code from rubycas-server by jzylks and matt.zukowski. # # Usage Example: # # #!/usr/bin/env ruby # # require 'rubygems' # require 'picnic/service_control' # # ctl = Picnic::ServiceControl.new('foo') # ctl.handle_cli_input # # The file containing this code can now be used to control the Picnic # app 'foo'. # # For, example, lets say you put this in a file called <tt>foo-ctl</tt>. # You can now use <tt>foo-ctl</tt> on the command line as follows: # # chmod +x foo-ctl # ./foo-ctl -h # ./foo-ctl start --verbose --config /etc/foo/config.yml # ./foo-ctl stop --config /etc/foo/config.yml # # Your <tt>foo-ctl</tt> script can also be used as part of Linux's init.d # mechanism for launching system services. To do this, create the file # <tt>/etc/init.d/foo</tt> and make sure that it is executable. It will # look something like the following (this may vary depending on your Linux # distribution; this example is for SuSE): # # #!/bin/sh # CTL=foo-ctl # . /etc/rc.status # # rc_reset # case "$1" in # start) # $CTL start # rc_status -v # ;; # stop) # $CTL stop # rc_status -v # ;; # restart) # $0 stop # $0 start # rc_status # ;; # status) # $CTL status # rc_status -v # ;; # *) # echo "Usage: $0 {start|stop|status|restart} # exit 1 # ;; # esac # rc_exit # # You should now be able to launch your application like any other init.d script # (just make sure that <tt>foo-ctl</tt> is installed in your executable <tt>PATH</tt> # -- if your application is properly installed as a RubyGem, this will be done automatically). # # On most Linux systems, you can make your app start up automatically during boot by calling: # # chkconfig -a foo # # On Debian and Ubuntu, it's: # # update-rc.d foo defaults # class ServiceControl attr_accessor :app, :options # Creates a new service controller. # # +app+:: The name of the application. This should match the name of the # binary, which by default is expected to be in the same directory # as the service control script. # +options+:: A hash overriding default options. The options are: # +bin_file+:: The name of the binary file that this control # script will use to start and stop your app. # +pid_file+:: Where the app's PID file (containing the app's # process ID) should be placed. # +verbose+:: True if the service control script should report # everything that it's doing to STDOUT. def initialize(app, options = {}) @app = app @options = options @options[:bin_file] ||= "bin/#{app}" @options[:pid_file] ||= "/etc/#{app}/#{app}.pid" @options[:conf_file] ||= nil @options[:verbose] ||= false @options = options end # Parses command line options given to the service control script. def handle_cli_input OptionParser.new do |opts| opts.banner = "Usage: #{$0} (start|stop|restart) [options]" opts.banner += "\n#{app} is only usable when using webrick or mongrel" opts.on("-c", "--config FILE", "Path to #{app} configuration file") { |value| @options[:conf_file] = value } opts.on("-P", "--pid_file FILE", "Path to #{app} pid file") { |value| @options[:pid_file] = value } opts.on('-v', '--verbose', "Print debugging information to the console") { |value| @options[:verbose] = value } if ARGV.empty? puts opts exit else @cmd = opts.parse!(ARGV) if @cmd.nil? puts opts exit end end end if !@options[:conf_file].nil? && !File.exists?(@options[:conf_file]) puts "Invalid path to #{app} configuration file: #{@options[:conf_file]}" exit end case @cmd[0] when "start": puts "Starting #{app}..." start when "stop": puts "Stopping #{app}..." stop when "restart": puts "Restarting #{app}..." stop start when "status": puts "Checking status of #{app}..." status else puts "Invalid command. Usage: #{app}-ctl [-cPv] start|stop|restart|status" end exit end def start # use local app bin if it exists and is executable -- makes debugging easier bin = options[:bin_file] if File.exists?(bin) exec = "ruby #{bin}" else exec = app end case get_state when :ok $stderr.puts "#{app} is already running" exit 1 when :not_running_pid, :empty_pid $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " The pid file will be automatically deleted for you, but this shouldn't have happened!" File.delete(@options[:pid_file]) when :dead $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " Please delete the pid file first." exit 1 when :running_missing_pid $stderr.puts "#{app} is already running (pid file is missing)." exit 1 when :not_running_no_pid # we should be good to go else $stderr.puts "#{app} could not be started. Try looking in the log file for more info." exit 1 end cmd = "#{exec} -d -P #{@options[:pid_file]}" cmd += " -c #{@options[:conf_file]}" if !@options[:conf_file].nil? puts "<<< #{cmd}" if @options[:verbose] output = `#{cmd}` puts ">>> #{output}" if @options[:verbose] sleep (1) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :ok exit 0 else $stderr.puts "\n#{app} could not start properly!\nTry running with the --verbose option for details." case s when :running_missing_pid exit 2 when :not_running_no_pid exit 4 when :not_running_pid exit 3 when :dead exit 1 else exit 4 end end end def stop killSigs = ['TERM','SYS', 'QUIT', 'KILL'] if File.exists? @options[:pid_file] pid = open(@options[:pid_file]).read.to_i for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else pid=`pgrep #{app}` pid.chomp! puts ">>> Stopping with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid.to_i) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else $stderr.puts "#{app} is already stopped." exit 4 end end end def status s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] case s when :ok puts "#{app} appears to be up and running." exit 0 when :not_running_pid $stderr.puts "#{app} does not appear to be running (pid file exists)." exit 3 when :empty_pid $stderr.puts "#{app} does not appear to be running (pid file exists but is empty)." when :not_running_no_pid $stderr.puts "#{app} is not running." exit 1 when :running_missing_pid $stderr.puts "#{app} is running (pid file is missing)." exit 1 when :dead $stderr.puts "#{app} is dead or unresponsive." exit 102 end end def get_state # FIXME: This is a poor attempt at trying to fix a problem where occassionally # an empty pid_file is read, probably because it has not yet been # fully written. sleep 0.5 if File.exists? @options[:pid_file] pid = File.read(@options[:pid_file]).strip puts ">>> Getting state with pid file: #{pid}" if options[:verbose] return :empty_pid unless pid and !pid.empty? # pid file exists but is empty # # Changed 'state=' to 's=' so that this works on Solaris # # The following line modified by Shane Swartz # state = `ps -p #{pid} -o state=`.strip state = `ps -p #{pid} -o s=`.strip puts ">>> pid file: #{pid} - state: #{state}" if options[:verbose] if state == '' return :not_running_pid elsif state == 'O' || state == 'R' || state == 'S' return :ok else return :dead end else # TODO: scan through the process table to see if server is running without pid file # The following code added by Shane Swartz pid=`pgrep #{app}` pid.chomp! puts ">>> Getting state with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? state = `ps -p #{pid} -o s=`.strip puts ">>> No pid file - state: #{state}" if options[:verbose] if state == '' return :not_running_no_pid elsif state == 'O' || state == 'R' || state == 'S' return :running_missing_pid else return :dead end else return :not_running_no_pid end end end end end

The service_control.rb file has some TODO's in it that I've completed in order to allow the rubycas-server rubycas-server-ctl script to work. Here is the updated service_control.rb file: require 'optparse' module Picnic # Provides functionality for controlling a Picnic-based server as # an init.d service. # # Based on code from rubycas-server by jzylks and matt.zukowski. # # Usage Example: # # #!/usr/bin/env ruby # # require 'rubygems' # require 'picnic/service_control' # # ctl = Picnic::ServiceControl.new('foo') # ctl.handle_cli_input # # The file containing this code can now be used to control the Picnic # app 'foo'. # # For, example, lets say you put this in a file called <tt>foo-ctl</tt>. # You can now use <tt>foo-ctl</tt> on the command line as follows: # # chmod +x foo-ctl # ./foo-ctl -h # ./foo-ctl start --verbose --config /etc/foo/config.yml # ./foo-ctl stop --config /etc/foo/config.yml # # Your <tt>foo-ctl</tt> script can also be used as part of Linux's init.d # mechanism for launching system services. To do this, create the file # <tt>/etc/init.d/foo</tt> and make sure that it is executable. It will # look something like the following (this may vary depending on your Linux # distribution; this example is for SuSE): # # #!/bin/sh # CTL=foo-ctl # . /etc/rc.status # # rc_reset # case "$1" in # start) # $CTL start # rc_status -v # ;; # stop) # $CTL stop # rc_status -v # ;; # restart) # $0 stop # $0 start # rc_status # ;; # status) # $CTL status # rc_status -v # ;; # *) # echo "Usage: $0 {start|stop|status|restart} # exit 1 # ;; # esac # rc_exit # # You should now be able to launch your application like any other init.d script # (just make sure that <tt>foo-ctl</tt> is installed in your executable <tt>PATH</tt> # -- if your application is properly installed as a RubyGem, this will be done automatically). # # On most Linux systems, you can make your app start up automatically during boot by calling: # # chkconfig -a foo # # On Debian and Ubuntu, it's: # # update-rc.d foo defaults # class ServiceControl attr_accessor :app, :options # Creates a new service controller. # # +app+:: The name of the application. This should match the name of the # binary, which by default is expected to be in the same directory # as the service control script. # +options+:: A hash overriding default options. The options are: # +bin_file+:: The name of the binary file that this control # script will use to start and stop your app. # +pid_file+:: Where the app's PID file (containing the app's # process ID) should be placed. # +verbose+:: True if the service control script should report # everything that it's doing to STDOUT. def initialize(app, options = {}) @app = app @options = options @options[:bin_file] ||= "bin/#{app}" @options[:pid_file] ||= "/etc/#{app}/#{app}.pid" @options[:conf_file] ||= nil @options[:verbose] ||= false @options = options end # Parses command line options given to the service control script. def handle_cli_input OptionParser.new do |opts| opts.banner = "Usage: #{$0} (start|stop|restart) [options]" opts.banner += "\n#{app} is only usable when using webrick or mongrel" opts.on("-c", "--config FILE", "Path to #{app} configuration file") { |value| @options[:conf_file] = value } opts.on("-P", "--pid_file FILE", "Path to #{app} pid file") { |value| @options[:pid_file] = value } opts.on('-v', '--verbose', "Print debugging information to the console") { |value| @options[:verbose] = value } if ARGV.empty? puts opts exit else @cmd = opts.parse!(ARGV) if @cmd.nil? puts opts exit end end end if !@options[:conf_file].nil? && !File.exists?(@options[:conf_file]) puts "Invalid path to #{app} configuration file: #{@options[:conf_file]}" exit end case @cmd[0] when "start": puts "Starting #{app}..." start when "stop": puts "Stopping #{app}..." stop when "restart": puts "Restarting #{app}..." stop start when "status": puts "Checking status of #{app}..." status else puts "Invalid command. Usage: #{app}-ctl [-cPv] start|stop|restart|status" end exit end def start # use local app bin if it exists and is executable -- makes debugging easier bin = options[:bin_file] if File.exists?(bin) exec = "ruby #{bin}" else exec = app end case get_state when :ok $stderr.puts "#{app} is already running" exit 1 when :not_running_pid, :empty_pid $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " The pid file will be automatically deleted for you, but this shouldn't have happened!" File.delete(@options[:pid_file]) when :dead $stderr.puts "The pid file '#{@options[:pid_file]}' exists but #{app} is not running." + " Please delete the pid file first." exit 1 when :running_missing_pid $stderr.puts "#{app} is already running (pid file is missing)." exit 1 when :not_running_no_pid # we should be good to go else $stderr.puts "#{app} could not be started. Try looking in the log file for more info." exit 1 end cmd = "#{exec} -d -P #{@options[:pid_file]}" cmd += " -c #{@options[:conf_file]}" if !@options[:conf_file].nil? puts "<<< #{cmd}" if @options[:verbose] output = `#{cmd}` puts ">>> #{output}" if @options[:verbose] sleep (1) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :ok exit 0 else $stderr.puts "\n#{app} could not start properly!\nTry running with the --verbose option for details." case s when :running_missing_pid exit 2 when :not_running_no_pid exit 4 when :not_running_pid exit 3 when :dead exit 1 else exit 4 end end end def stop killSigs = ['TERM','SYS', 'QUIT', 'KILL'] if File.exists? @options[:pid_file] pid = open(@options[:pid_file]).read.to_i for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else pid=`pgrep #{app}` pid.chomp! puts ">>> Stopping with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? for signal in killSigs begin puts ">>> Attempting to kill with signal #{signal}" if options[:verbose] Process.kill(signal, pid.to_i) sleep(3) s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 end rescue Errno::ESRCH $stderr.puts "#{app} process '#{pid}' does not exist." exit 1 end end s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] if s == :not_running_pid begin puts ">>> Stopped #{app} attempting to delete pid file" if options[:verbose] File.delete(@options[:pid_file]) rescue Exception $stderr.puts "Failed to remove the pid file '#{@options[:pid_file]}'." exit 1 end exit 0 elsif s == :not_running_no_pid exit 0 else $stderr.puts "\n#{app} could not stop properly!\nTry running with the --verbose option for details." case s when :ok exit 3 when :dead exit 1 when :running_missing_pid exit 2 else exit 4 end end else $stderr.puts "#{app} is already stopped." exit 4 end end end def status s = get_state puts ">>> STATE: #{s.to_s}" if options[:verbose] case s when :ok puts "#{app} appears to be up and running." exit 0 when :not_running_pid $stderr.puts "#{app} does not appear to be running (pid file exists)." exit 3 when :empty_pid $stderr.puts "#{app} does not appear to be running (pid file exists but is empty)." when :not_running_no_pid $stderr.puts "#{app} is not running." exit 1 when :running_missing_pid $stderr.puts "#{app} is running (pid file is missing)." exit 1 when :dead $stderr.puts "#{app} is dead or unresponsive." exit 102 end end def get_state # FIXME: This is a poor attempt at trying to fix a problem where occassionally # an empty pid_file is read, probably because it has not yet been # fully written. sleep 0.5 if File.exists? @options[:pid_file] pid = File.read(@options[:pid_file]).strip puts ">>> Getting state with pid file: #{pid}" if options[:verbose] return :empty_pid unless pid and !pid.empty? # pid file exists but is empty # # Changed 'state=' to 's=' so that this works on Solaris # # The following line modified by Shane Swartz # state = `ps -p #{pid} -o state=`.strip state = `ps -p #{pid} -o s=`.strip puts ">>> pid file: #{pid} - state: #{state}" if options[:verbose] if state == '' return :not_running_pid elsif state == 'O' || state == 'R' || state == 'S' return :ok else return :dead end else # TODO: scan through the process table to see if server is running without pid file # The following code added by Shane Swartz pid=`pgrep #{app}` pid.chomp! puts ">>> Getting state with no pid file - pid: <#{pid}>" if options[:verbose] if !pid.empty? state = `ps -p #{pid} -o s=`.strip puts ">>> No pid file - state: #{state}" if options[:verbose] if state == '' return :not_running_no_pid elsif state == 'O' || state == 'R' || state == 'S' return :running_missing_pid else return :dead end else return :not_running_no_pid end end end end end

Earlier this year

Older