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

1. Provides functionality for controlling a Picnic-based server as
2. an init.d service.
4. Based on code from rubycas-server by jzylks and matt.zukowski.
6. Usage Example:
8. #!/usr/bin/env ruby
10. require 'rubygems'
11. require 'picnic/service_control'
13. ctl = Picnic::ServiceControl?.new('foo')
14. ctl.handle_cli_input
16. The file containing this code can now be used to control the Picnic
17. app 'foo'.
19. For, example, lets say you put this in a file called <tt>foo-ctl</tt>.
20. You can now use <tt>foo-ctl</tt> on the command line as follows:
22. chmod +x foo-ctl
23. ./foo-ctl -h
24. ./foo-ctl start --verbose --config /etc/foo/config.yml
25. ./foo-ctl stop --config /etc/foo/config.yml
27. Your <tt>foo-ctl</tt> script can also be used as part of Linux's init.d
28. mechanism for launching system services. To do this, create the file
29. <tt>/etc/init.d/foo</tt> and make sure that it is executable. It will
30. look something like the following (this may vary depending on your Linux
31. distribution; this example is for SuSE):
33. #!/bin/sh
34. CTL=foo-ctl
35. . /etc/rc.status
37. rc_reset
38. case "$1" in
39. start)
40. $CTL start
41. rc_status -v
42. ;;
43. stop)
44. $CTL stop
45. rc_status -v
46. ;;
47. restart)
48. $0 stop
49. $0 start
50. rc_status
51. ;;
52. status)
53. $CTL status
54. rc_status -v
55. ;;
56. )
57. echo "Usage: $0 {start|stop|status|restart}
58. exit 1
59. ;;
60. esac
61. rc_exit
63. You should now be able to launch your application like any other init.d script
64. (just make sure that <tt>foo-ctl</tt> is installed in your executable <tt>PATH</tt>
65. -- if your application is properly installed as a RubyGem?, this will be done automatically).
67. On most Linux systems, you can make your app start up automatically during boot by calling:
69. chkconfig -a foo
71. On Debian and Ubuntu, it's:
73. update-rc.d foo defaults

class ServiceControl?

attr_accessor :app, :options

1. Creates a new service controller.
3. +app+:: The name of the application. This should match the name of the
4. binary, which by default is expected to be in the same directory
5. as the service control script.
6. +options+:: A hash overriding default options. The options are:
7. +bin_file+:: The name of the binary file that this control
8. script will use to start and stop your app.
9. +pid_file+:: Where the app's PID file (containing the app's
10. process ID) should be placed.
11. +verbose+:: True if the service control script should report
12. 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

1. 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 @cmd0? 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

1. 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

1. 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 = '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

1. FIXME: This is a poor attempt at trying to fix a problem where occassionally
2. an empty pid_file is read, probably because it has not yet been
3. 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 == 'S'

state == 'R'

return :ok

else

return :dead

end

else

1. TODO: scan through the process table to see if server is running without pid file
2. 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 == 'S'

state == 'R'

return :running_missing_pid

else

return :dead

end

else

return :not_running_no_pid

end

end

end

end

end