daemon-spawn-tanin 0.4.3

data/.autotest

@@ -0,0 +1,16 @@
+Autotest.add_hook(:initialize) do |at|
+  at.clear_mappings
+
+  at.add_mapping(/.*flymake/) do |f, _|
+    []
+  end
+
+  at.add_mapping(%r[lib/daemon-spawn.rb]) do |f, _|
+    at.files_matching /^test\/.*_test\.rb$/
+  end
+
+  at.add_mapping(/^test\/.*_test\.rb$/) do |filename, _|
+    filename
+  end
+
+end

data/.gitignore

@@ -0,0 +1,2 @@
+doc
+pkg

data/History.txt

@@ -0,0 +1,32 @@
+=== 0.4.2 / 2011-04-01
+
+* Merged patches from Tilo Prütz
+
+=== 0.4.1 / 2011-03-03
+
+* Merged patch from oruen to fix https://github.com/alexvollmer/daemon-spawn/issues/5
+
+=== 0.4.0 / 2010-09-05
+
+* Lots of fixes from friendly folks
+
+=== 0.3.0 / 2010-04-18
+
+* Typo fix and internal refactoring patches from Emmanuel Gomez
+* Added multi-process spawning and management (inspired by Jontathan Tropper's
+  patches)
+* Added LSB-compliance patches from  Woody Peterson
+* Added some actual test-coverage :-P
+* Moved examples from "examples" directory to "test/servers"
+
+=== 0.2.0 / 2009-04-22
+
+* Allow specification of args instead of ARGV so that scripts can
+  handle command line parsing and validation prior to spawning.
+
+=== 0.1.0 / 2009-01-26
+
+* 1 major enhancement
+
+  * Happy Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/daemon_spawn.rb
+test/daemon_spawn_test.rb
+test/multi_daemon_spawn_test.rb
+test/servers/echo_server.rb
+test/servers/simple_server.rb

data/README.rdoc

@@ -0,0 +1,107 @@
+= daemon-spawn
+
+* http://github.com/alexvollmer/daemon-spawn
+
+== DESCRIPTION
+
+Daemon launching and management made dead simple.
+
+With daemon-spawn you can start, stop and restart processes that run
+in the background. Processed are tracked by a simple PID file written
+to disk.
+
+In addition, you can choose to either execute ruby in your daemonized
+process or 'exec' another process altogether (handy for wrapping other
+services).
+
+== SYNOPSIS
+
+=== WRITING A DAEMON
+
+To create a new spawner, write a class that extends <tt>DaemonSpawn::Base</tt>
+and provides +start+ and +stop+ methods. For example:
+
+  class MyServer < DaemonSpawn::Base
+
+    def start(args)
+      # process command-line args
+      # start your bad self
+    end
+
+    def stop
+      # stop your bad self
+    end
+  end
+
+  MyServer.spawn!(:log_file => '/var/log/echo_server.log',
+                  :pid_file => '/var/run/echo_server.pid',
+                  :sync_log => true,
+                  :working_dir => File.dirname(__FILE__))
+
+If you need command-line parameters, any arguments passed after one of
+the commands (start, stop, status or restart) will be passed to the
++start+ method.
+
+The <tt>spawn!</tt> method takes a hash of symbolized keys. At a minimum you
+_must_ specify the <tt>:working_dir</tt> option. You can also override
+the default locations for the log and PID files.
+
+If you pass a <tt>:processes</tt> option to the <tt>spawn!</tt>,
+daemon spawn will start that number of processes.
+
+See the <tt>test/servers</tt> directory for working examples.
+
+=== RUNNING A DAEMON
+
+Let's say that you have the example script listed above in
+<tt>bin/my_server</tt>. Here are the commands for starting, querying
+the status, restarting and stopping the daemon:
+
+  bin/my_server start
+  bin/my_server status
+  bin/my_server restart
+  bin/my_server stop
+
+Note that if any additional arguments are passed to either
+<tt>start</tt> or <tt>restart</tt> those will be passed to the +start+
+method of an instance of your daemon class.
+
+
+== REQUIREMENTS
+
+None!
+
+== CONTRIBUTIONS
+
+Feel free to fork this project and send me pull requests with any
+changes that you have. Please note that I won't accept any patches
+with significant formatting changes or ones without tests.
+
+== INSTALL
+
+* sudo gem install daemon-spawn
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009 Evri, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# -*- ruby -*-
+
+require 'rubygems'
+require './lib/daemon_spawn.rb'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "daemon-spawn"
+    gemspec.summary = "Daemon launching and management made dead simple"
+    gemspec.description = %Q[With daemon-spawn you can start, stop and restart processes that run
+    in the background. Processed are tracked by a simple PID file written
+    to disk.]
+    gemspec.rubyforge_project = "daemon-spawn"
+    gemspec.email = "alex.vollmer@gmail.com"
+    gemspec.homepage = "http://github.com/alexvollmer/daemon-spawn"
+    gemspec.authors = ["Alex Vollmer", "Seamus Abshere", "Emmanual Gomez", "Seth Falcon", "Woody Peterson", "Tilo Prütz"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*test.rb']
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test
+# vim: syntax=Ruby

data/VERSION

@@ -0,0 +1 @@
+0.4.2

data/daemon-spawn-tanin.gemspec

@@ -0,0 +1,66 @@
+# 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{daemon-spawn-tanin}
+  s.version = "0.4.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Vollmer", "Seamus Abshere", "Emmanual Gomez", "Seth Falcon", "Woody Peterson", "Tilo Pr\303\274tz","Tanin Na Nakorn"]
+  s.date = %q{2011-08-24}
+  s.description = %q{With daemon-spawn you can start, stop and restart processes that run
+    in the background. Processed are tracked by a simple PID file written
+    to disk.}
+  s.email = %q{alex.vollmer@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     "History.txt",
+     "Manifest.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "daemon-spawn-tanin.gemspec",
+     "lib/daemon_spawn.rb",
+     "test/daemon_spawn_test.rb",
+     "test/test_helper.rb",
+     "test/multi_daemon_spawn_test.rb",
+     "test/servers/deaf_server.rb",
+     "test/servers/echo_server.rb",
+     "test/servers/simple_server.rb",
+     "test/servers/stubborn_server.rb",
+     "test/servers/taps_server.rb"
+  ]
+  s.homepage = %q{http://github.com/alexvollmer/daemon-spawn}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{daemon-spawn}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Daemon launching and management made dead simple}
+  s.test_files = [
+    "test/daemon_spawn_test.rb",
+     "test/test_helper.rb",
+     "test/multi_daemon_spawn_test.rb",
+     "test/servers/deaf_server.rb",
+     "test/servers/echo_server.rb",
+     "test/servers/simple_server.rb",
+     "test/servers/stubborn_server.rb",
+     "test/servers/taps_server.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/daemon_spawn.rb

@@ -0,0 +1,213 @@
+require 'fileutils'
+
+# Large portions of this were liberally stolen from the
+# 'simple-daemon' project at http://simple-daemon.rubyforge.org/
+module DaemonSpawn
+  VERSION = '0.3.0'
+
+  def self.usage(msg=nil) #:nodoc:
+    print "#{msg}, " if msg
+    puts "usage: #{$0} <command> [options]"
+    puts "Where <command> is one of start, stop, restart or status"
+    puts "[options] are additional options passed to the underlying process"
+  end
+
+  def self.alive?(pid)
+    Process.kill 0, pid
+  rescue Errno::ESRCH
+    false
+  end
+
+  def self.start(daemon, args) #:nodoc:
+    if !File.writable?(File.dirname(daemon.log_file))
+      STDERR.puts "Unable to write log file to #{daemon.log_file}"
+      exit 1
+    end
+
+    if !File.writable?(File.dirname(daemon.pid_file))
+      STDERR.puts "Unable to write PID file to #{daemon.pid_file}"
+      exit 1
+    end
+
+    if daemon.alive? && daemon.singleton
+      STDERR.puts "An instance of #{daemon.app_name} is already " +
+        "running (PID #{daemon.pid})"
+      exit 0
+    end
+
+    fork do
+      Process.setsid
+      exit if fork
+      open(daemon.pid_file, 'w') { |f| f << Process.pid }
+      Dir.chdir daemon.working_dir
+      old_umask = File.umask 0000
+      log = File.new(daemon.log_file, "a")
+      File.umask old_umask
+      log.sync = daemon.sync_log
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen log
+      STDERR.reopen STDOUT
+      trap("TERM") {daemon.stop; exit}
+      daemon.start(args)
+    end
+    puts "#{daemon.app_name} started."
+  end
+
+  def self.stop(daemon) #:nodoc:
+    if pid = daemon.pid
+      FileUtils.rm(daemon.pid_file)
+      Process.kill(daemon.signal, pid)
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+      end
+      if ticks = daemon.timeout
+        while ticks > 0 and alive?(pid) do
+          puts "Process is still alive. #{ticks} seconds until I kill -9 it..."
+          sleep 1
+          ticks -= 1
+        end
+        if alive?(pid)
+          puts "Process didn't quit after timeout of #{daemon.timeout} seconds. Killing..."
+          Process.kill 9, pid
+        end
+      end
+    else
+      puts "PID file not found. Is the daemon started?"
+    end
+  rescue Errno::ESRCH
+    puts "PID file found, but process was not running. The daemon may have died."
+  end
+
+  def self.status(daemon) #:nodoc:
+    puts "#{daemon.app_name} is #{daemon.alive? ? "" : "NOT "}running (PID #{daemon.pid})"
+  end
+
+  class Base
+    attr_accessor :log_file, :pid_file, :sync_log, :working_dir, :app_name, :singleton, :index, :signal, :timeout
+
+    def initialize(opts = {})
+      raise 'You must specify a :working_dir' unless opts[:working_dir]
+      self.working_dir = opts[:working_dir]
+      self.app_name = opts[:application] || classname
+      self.pid_file = opts[:pid_file] || File.join(working_dir, 'tmp', 'pids', app_name + '.pid')
+      self.log_file = opts[:log_file] || File.join(working_dir, 'logs', app_name + '.log')
+      self.signal = opts[:signal] || 'TERM'
+      self.timeout = opts[:timeout]
+      self.index = opts[:index] || 0
+      if self.index > 0
+        self.pid_file += ".#{self.index}"
+        self.log_file += ".#{self.index}"
+      end
+      self.sync_log = opts[:sync_log]
+      self.singleton = opts[:singleton] || false
+    end
+
+    def classname #:nodoc:
+      self.class.to_s.split('::').last
+    end
+
+    # Provide your implementation. These are provided as a reminder
+    # only and will raise an error if invoked. When started, this
+    # method will be invoked with the remaining command-line arguments.
+    def start(args)
+      raise "You must implement a 'start' method in your class!"
+    end
+
+    # Provide your implementation. These are provided as a reminder
+    # only and will raise an error if invoked.
+    def stop
+      raise "You must implement a 'stop' method in your class!"
+    end
+
+    def alive? #:nodoc:
+      if File.file?(pid_file)
+        DaemonSpawn.alive? pid
+      else
+        false
+      end
+    end
+
+    def pid #:nodoc:
+      IO.read(self.pid_file).to_i rescue nil
+    end
+
+    def self.build(options)
+      count = options.delete(:processes) || 1
+      daemons = []
+      count.times do |index|
+        daemons << new(options.merge(:index => index))
+      end
+      daemons
+    end
+
+    def self.find(options)
+      pid_file = new(options).pid_file
+      basename = File.basename(pid_file).split('.').first
+      pid_files = Dir.glob(File.join(File.dirname(pid_file), "#{basename}.*pid*"))
+      pid_files.map { |f| new(options.merge(:pid_file => f)) }
+    end
+
+    # Invoke this method to process command-line args and dispatch
+    # appropriately. Valid options include the following _symbols_:
+    # - <tt>:working_dir</tt> -- the working directory (required)
+    # - <tt>:log_file</tt> -- path to the log file
+    # - <tt>:pid_file</tt> -- path to the pid file
+    # - <tt>:sync_log</tt> -- indicate whether or not to sync log IO
+    # - <tt>:singleton</tt> -- If set to true, only one instance is
+    # allowed to start
+    # args must begin with 'start', 'stop', 'status', or 'restart'.
+    # The first token will be removed and any remaining arguments
+    # passed to the daemon's start method.
+    def self.spawn!(opts = {}, args = ARGV)
+      case args.any? and command = args.shift
+      when 'start', 'stop', 'status', 'restart'
+        send(command, opts, args)
+      when '-h', '--help', 'help'
+        DaemonSpawn.usage
+        #exit
+      else
+        DaemonSpawn.usage "Invalid command"
+        #exit 1
+      end
+    end
+
+    def self.start(opts, args)
+      living_daemons = find(opts).select { |d| d.alive? }
+      if living_daemons.any?
+        puts "Daemons already started! PIDS: #{living_daemons.map {|d| d.pid}.join(', ')}"
+        #exit 1
+      else
+        build(opts).map { |d| DaemonSpawn.start(d, args) }
+      end
+    end
+
+    def self.stop(opts, args)
+      daemons = find(opts)
+      if daemons.empty?
+        puts "No PID files found. Is the daemon started?"
+        #exit 1
+      else
+        daemons.each { |d| DaemonSpawn.stop(d) }
+      end
+    end
+
+    def self.status(opts, args)
+      daemons = find(opts)
+      if daemons.empty?
+        puts 'No PIDs found'
+      else
+        daemons.each { |d| DaemonSpawn.status(d) }
+      end
+    end
+
+    def self.restart(opts, args)
+      daemons = build(opts)
+      daemons.map do |daemon|
+        DaemonSpawn.stop(daemon)
+        sleep 0.1
+        DaemonSpawn.start(daemon, args)
+      end
+    end
+  end
+end

data/test/daemon_spawn_test.rb

@@ -0,0 +1,211 @@
+require 'test_helper'
+require "socket"
+
+class DaemonSpawnTest < Test::Unit::TestCase
+
+  SERVERS = File.join(File.dirname(__FILE__), "servers")
+
+  # Try to make sure no pidfile (or process) is left over from another test.
+  def setup
+    %w{ echo_server deaf_server stubborn_server simple_server }.each do |server|
+      begin
+        Process.kill 9, possible_pid(server)
+      rescue Errno::ESRCH
+        # good, no process to kill
+      end
+      begin
+        File.unlink pid_file(server)
+      rescue Errno::ENOENT
+        # good, no pidfile to clear
+      end
+    end
+  end
+
+  def with_socket
+    socket = TCPSocket.new('127.0.0.1', 5150)
+    socket.setsockopt(Socket::SOL_SOCKET,
+                      Socket::SO_RCVTIMEO,
+                      [1, 0].pack("l_2"))
+
+    begin
+      yield(socket) if block_given?
+    ensure
+      socket.close
+    end
+  end
+
+  def echo_server(*args)
+    `./echo_server.rb #{args.join(' ')}`
+  end
+
+  def while_running(&block)
+    Dir.chdir(SERVERS) do
+      `./echo_server.rb stop`
+      assert_match(/EchoServer started./, `./echo_server.rb start 5150`)
+      sleep 1
+      begin
+        with_socket &block
+      ensure
+        assert_match(//, `./echo_server.rb stop`)
+        sleep 0.1
+        assert_raises(Errno::ECONNREFUSED) { TCPSocket.new('127.0.0.1', 5150) }
+      end
+    end
+  end
+
+  def after_daemon_dies_leaving_pid_file
+    Dir.chdir(SERVERS) do
+      `./echo_server.rb stop`
+      sleep 1
+      `./echo_server.rb start 5150`
+      sleep 1
+      leftover_pid = IO.read(pid_file('echo_server')).to_i
+      Process.kill 9, leftover_pid
+      sleep 1
+      assert dead?(leftover_pid)
+      assert File.exists?(pid_file('echo_server'))
+      yield leftover_pid
+    end
+  end
+
+  def test_daemon_running
+    while_running do |socket|
+      socket << "foobar\n"
+      assert_equal "foobar\n", socket.readline
+    end
+  end
+
+  def test_status_running
+    while_running do |socket|
+      assert_match(/EchoServer is running/, `./echo_server.rb status`)
+    end
+  end
+
+  def test_status_not_running
+    Dir.chdir(SERVERS) do
+      assert_match(/No PIDs found/, `./echo_server.rb status`)
+    end
+  end
+
+  def test_start_after_started
+    while_running do
+      pid = echo_server("status").match(/PID (\d+)/)[1]
+      assert_match(/Daemons already started! PIDS: #{pid}/,
+                   echo_server("start"))
+    end
+  end
+
+  def test_stop_after_stopped
+    Dir.chdir(SERVERS) do
+      assert_match("No PID files found. Is the daemon started?",
+                   `./echo_server.rb stop`)
+    end
+  end
+
+  def test_restart_after_stopped
+    Dir.chdir(SERVERS) do
+      assert_match(/EchoServer started/, `./echo_server.rb restart 5150`)
+      assert_equal(0, $?.exitstatus)
+      sleep 1
+      with_socket do |socket|
+        socket << "foobar\n"
+        assert_equal "foobar\n", socket.readline
+      end
+    end
+  end
+
+  def test_restart_after_started
+    Dir.chdir(SERVERS) do
+      assert_match(/EchoServer started/, `./echo_server.rb start 5150`)
+      assert_equal(0, $?.exitstatus)
+      sleep 1
+
+      assert_match(/EchoServer started/, `./echo_server.rb restart 5150`)
+      assert_equal(0, $?.exitstatus)
+      sleep 1
+
+      with_socket do |socket|
+        socket << "foobar\n"
+        assert_equal "foobar\n", socket.readline
+      end
+    end
+  end
+
+  def test_start_after_daemon_dies_leaving_pid_file
+    after_daemon_dies_leaving_pid_file do |leftover_pid|
+      assert_match /EchoServer started/, `./echo_server.rb start 5150`
+      sleep 1
+      new_pid = IO.read(pid_file('echo_server')).to_i
+      assert new_pid != leftover_pid
+      assert alive?(new_pid)
+    end
+  end
+
+  def test_restart_after_daemon_dies_leaving_pid_file
+    after_daemon_dies_leaving_pid_file do |leftover_pid|
+      assert_match /EchoServer started/, `./echo_server.rb restart 5150`
+      sleep 1
+      new_pid = reported_pid 'echo_server'
+      assert new_pid != leftover_pid
+      assert alive?(new_pid)
+    end
+  end
+
+  def test_stop_using_custom_signal
+    Dir.chdir(SERVERS) do
+      `./deaf_server.rb start`
+      sleep 1
+      pid = reported_pid 'deaf_server'
+      assert alive?(pid)
+      Process.kill 'TERM', pid
+      sleep 1
+      assert alive?(pid)
+      Process.kill 'INT', pid
+      sleep 1
+      assert alive?(pid)
+      `./deaf_server.rb stop`
+      sleep 1
+      assert dead?(pid)
+    end
+  end
+
+  def test_kill_9_following_timeout
+    Dir.chdir(SERVERS) do
+      `./stubborn_server.rb start`
+      sleep 1
+      pid = reported_pid 'stubborn_server'
+      assert alive?(pid)
+      Process.kill 'TERM', pid
+      sleep 1
+      assert alive?(pid)
+      `./stubborn_server.rb stop`
+      assert dead?(pid)
+    end
+  end
+
+  def test_umask_unchanged
+    Dir.chdir(SERVERS) do
+      old_umask = File.umask 0124
+      log_file = File.join(Dir.tmpdir, 'should_not_be_world_writable')
+      begin
+        `./simple_server.rb stop`
+        FileUtils.rm_f log_file
+        `./simple_server.rb start #{log_file}`
+        sleep 1
+        assert_equal 0100642, File.stat(log_file).mode
+      ensure
+        `./simple_server.rb stop`
+        FileUtils.rm_f log_file
+        File.umask old_umask
+      end
+    end
+  end
+
+  def test_log_file_is_world_writable
+    log_file = File.join(Dir.tmpdir, 'echo_server.log')
+    FileUtils.rm_f log_file
+    while_running do
+      assert_equal 0100666, File.stat(log_file).mode
+    end
+  end
+end

data/test/multi_daemon_spawn_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+require "tempfile"
+
+class MultiDaemonSpawnTest < Test::Unit::TestCase
+
+  SERVERS = File.join(File.dirname(__FILE__), "servers")
+
+  def setup
+    @tmpfile = Tempfile.new("multi_daemon_spawn_test")
+  end
+
+  def tear_down
+    @tmpfile.delete
+  end
+
+  def simple_server(*args)
+    `./simple_server.rb #{args.join(" ")}`
+  end
+
+  def current_pids
+    regexp = /SimpleServer is running \(PID (\d+)\)/
+    pids = simple_server("status").split("\n").map do |line|
+      if m = regexp.match(line)
+        m[1]
+      else
+        nil
+      end
+    end.compact
+  end
+
+  def while_running
+    Dir.chdir(SERVERS) do
+      simple_server "stop"
+      simple_server "start", @tmpfile.path
+      sleep 1
+      begin
+        yield if block_given?
+      ensure
+        simple_server "stop"
+      end
+    end
+  end
+
+  def test_start_multiple
+    while_running do
+      lines = open(@tmpfile.path).readlines
+      assert_equal 2, lines.size
+      assert lines.member?("SimpleServer (0) started\n")
+      assert lines.member?("SimpleServer (1) started\n")
+    end
+  end
+
+  def test_status_multiple
+    while_running do
+      lines = simple_server("status").split("\n")
+      lines.each do |line|
+        assert_match /SimpleServer is running/, line
+      end
+    end
+  end
+
+  def test_stop_multiple
+    while_running
+    Dir.chdir(SERVERS) do
+      assert_match /No PIDs found/, simple_server("status")
+    end
+  end
+
+  def test_restart_multiple
+    while_running do
+      pids = current_pids
+      simple_server "restart"
+      new_pids = current_pids
+      assert_not_equal pids.sort, new_pids.sort
+    end
+  end
+
+  def test_status_with_one_dead_process
+    while_running do
+      pids = current_pids
+      Process.kill(9, pids[0].to_i)
+
+      lines = simple_server("status").split("\n")
+      assert_equal 2, lines.size
+      assert lines.member?("SimpleServer is NOT running (PID #{pids[0]})")
+      assert lines.member?("SimpleServer is running (PID #{pids[1]})")
+    end
+  end
+
+  def test_restart_with_one_dead_process
+    while_running do
+      pids = current_pids
+      Process.kill(9, pids[0].to_i)
+
+      lines = simple_server("restart").split("\n")
+      assert lines.member?("PID file found, but process was not running. The daemon may have died."), lines.inspect
+      assert_equal 2, lines.select { |l| l == "SimpleServer started." }.size
+
+      new_pids = current_pids
+      assert_not_equal new_pids, pids
+    end
+  end
+
+  def test_start_after_started
+    while_running do
+      pids = current_pids
+      assert_match(/Daemons already started! PIDS: #{pids.join(', ')}/,
+                   simple_server("start"))
+    end
+  end
+end

data/test/servers/deaf_server.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+require "tmpdir"
+
+# A server that only quits if you send it SIGWINCH
+class DeafServer < DaemonSpawn::Base
+  def start(args)
+    trap('TERM') { }
+    trap('INT')  { }
+    trap('SIGWINCH') { exit 0 }
+    loop do
+      sleep 100
+    end
+  end
+
+  def stop
+  end
+end
+
+DeafServer.spawn!(:working_dir => File.join(File.dirname(__FILE__), '..', '..'),
+                  :log_file => File.join(Dir.tmpdir, 'deaf_server.log'),
+                  :pid_file => File.join(Dir.tmpdir, 'deaf_server.pid'),
+                  :sync_log => true,
+                  :singleton => true,
+                  :signal => 'SIGWINCH')

data/test/servers/echo_server.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+require "socket"
+require "tmpdir"
+
+# An echo server using daemon-spawn. It starts up local TCP server
+# socket and repeats each line it receives on the connection. To fire
+# it up run:
+#   ./echo_server.rb start 12345
+# Then connect to it using telnet to test it:
+#   telnet localhost 12345
+#   > howdy!
+#   howdy!
+# to shut the daemon down, go back to the command-line and run:
+#  ./echo_server.rb stop
+class EchoServer < DaemonSpawn::Base
+
+  attr_accessor :server_socket
+
+  def start(args)
+    port = args.empty? ? 0 : args.first.to_i
+    self.server_socket = TCPServer.new('127.0.0.1', port)
+    self.server_socket.setsockopt(Socket::SOL_SOCKET,
+                                  Socket::SO_REUSEADDR,
+                                  true)
+    port = self.server_socket.addr[1]
+    puts "EchoServer started on port #{port}"
+    loop do
+      begin
+        client = self.server_socket.accept
+        puts "Got a connection from #{client}"
+        while str = client.gets
+          client.write(str)
+          puts "Echoed '#{str}' to #{client}"
+        end
+      rescue Errno::ECONNRESET => e
+        STDERR.puts "Client reset connection"
+      end
+    end
+  end
+
+  def stop
+    puts "Stopping EchoServer..."
+    self.server_socket.close if self.server_socket
+  end
+end
+
+EchoServer.spawn!(:working_dir => File.join(File.dirname(__FILE__), '..', '..'),
+                  :log_file => File.join(Dir.tmpdir, 'echo_server.log'),
+                  :pid_file => File.join(Dir.tmpdir, 'echo_server.pid'),
+                  :sync_log => true,
+                  :singleton => true)

data/test/servers/simple_server.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+
+class SimpleServer < DaemonSpawn::Base
+
+  attr_accessor :outfile
+
+  def start(args)
+    abort "USAGE: phrase_server.rb LOGFILE" if args.empty?
+    @outfile = args.first
+    self.puts "SimpleServer (#{self.index}) started"
+    while true                  # keep running like a real daemon
+      sleep 5
+    end
+  end
+
+  def puts(str)
+    open(@outfile, "a") { |f| f.puts str }
+  end
+
+  def stop
+    self.puts "SimpleServer (#{self.index}) stopped"
+  end
+
+end
+
+SimpleServer.spawn!(:working_dir => File.join(File.dirname(__FILE__), '..', '..'),
+                    :log_file => '/tmp/simple_server.log',
+                    :pid_file => '/tmp/simple_server.pid',
+                    :sync_log => true,
+                    :processes => 2)

data/test/servers/stubborn_server.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+require "tmpdir"
+
+# A server that needs to be kill -9'ed
+class StubbornServer < DaemonSpawn::Base
+  def start(args)
+    trap('TERM') { }
+    loop do
+      sleep 100
+    end
+  end
+
+  def stop
+    raise "You should never get to me"
+  end
+end
+
+StubbornServer.spawn!(:working_dir => File.join(File.dirname(__FILE__), '..', '..'),
+                      :log_file => File.join(Dir.tmpdir, 'stubborn_server.log'),
+                      :pid_file => File.join(Dir.tmpdir, 'stubborn_server.pid'),
+                      :sync_log => true,
+                      :singleton => true,
+                      :timeout => 2)

data/test/servers/taps_server.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+
+class TapsServer < DaemonSpawn::Base
+  def start(args)
+    sleep 5 # Sinatra takes its sweet time to shut down
+    Kernel.exec "/usr/bin/taps server mysql://dbusername:dbpassword@localhost/data1_production?encoding=utf8 username password"
+  end
+
+  def stop
+  end
+end
+TapsServer.spawn!(:working_dir => File.join(File.dirname(__FILE__), '..', '..'),
+                  :log_file => File.join(Dir.tmpdir, 'taps_server.log'),
+                  :pid_file => File.join(Dir.tmpdir, 'taps_server.pid'),
+                  :sync_log => true,
+                  :singleton => true,
+                  :signal => 'INT') # Sinatra ignores TERM

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+require "test/unit"
+require "tmpdir"
+
+class Test::Unit::TestCase
+  def pid_file(daemon_name)
+    File.join Dir.tmpdir, "#{daemon_name}.pid"
+  end
+
+  def possible_pid(daemon_name)
+    `ps x | grep ruby | grep #{daemon_name} | awk '{ print $1 }'`.to_i
+  end
+
+  def reported_pid(daemon_name)
+    IO.read(pid_file(daemon_name)).to_i
+  end
+
+  def alive?(pid)
+    Process.kill 0, pid
+  rescue Errno::ESRCH
+    false
+  end
+
+  def dead?(pid)
+    not alive? pid
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: daemon-spawn-tanin
+version: !ruby/object:Gem::Version
+  version: 0.4.3
+  prerelease: 
+platform: ruby
+authors:
+- Alex Vollmer
+- Seamus Abshere
+- Emmanual Gomez
+- Seth Falcon
+- Woody Peterson
+- Tilo Prütz
+- Tanin Na Nakorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 00:00:00.000000000Z
+dependencies: []
+description: ! "With daemon-spawn you can start, stop and restart processes that run\n
+  \   in the background. Processed are tracked by a simple PID file written\n    to
+  disk."
+email: alex.vollmer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- .autotest
+- .gitignore
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- daemon-spawn-tanin.gemspec
+- lib/daemon_spawn.rb
+- test/daemon_spawn_test.rb
+- test/test_helper.rb
+- test/multi_daemon_spawn_test.rb
+- test/servers/deaf_server.rb
+- test/servers/echo_server.rb
+- test/servers/simple_server.rb
+- test/servers/stubborn_server.rb
+- test/servers/taps_server.rb
+homepage: http://github.com/alexvollmer/daemon-spawn
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: daemon-spawn
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Daemon launching and management made dead simple
+test_files:
+- test/daemon_spawn_test.rb
+- test/test_helper.rb
+- test/multi_daemon_spawn_test.rb
+- test/servers/deaf_server.rb
+- test/servers/echo_server.rb
+- test/servers/simple_server.rb
+- test/servers/stubborn_server.rb
+- test/servers/taps_server.rb