seamusabshere-daemon-spawn 0.2.1

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,20 @@
+=== 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.txt

@@ -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,18 @@
+# -*- ruby -*-
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "seamusabshere-daemon-spawn"
+    gemspec.summary = "A simple, flexible daemon management library. (re-released by Seamus Abshere)"
+    gemspec.description = %{gem 0.3.0 re-release... originally at http://github.com/alexvollmer/daemon-spawn}
+    gemspec.email = "seamus@abshere.net"
+    gemspec.homepage = "http://github.com/seamusabshere/daemon-spawn"
+    gemspec.authors = ["Alex Vollmer"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+# vim: syntax=Ruby

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/daemon-spawn.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{daemon-spawn}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Vollmer"]
+  s.date = %q{2009-09-21}
+  s.description = %q{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).}
+  s.email = ["alex.vollmer@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "lib/daemon-spawn.rb", "test/test_daemon-spawn.rb", "examples/echo_server.rb"]
+  s.homepage = %q{http://github.com/alexvollmer/daemon-spawn}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{daemon-spawn}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Daemon launching and management made dead simple}
+  s.test_files = ["test/test_daemon-spawn.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.3.3"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.3.3"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.3.3"])
+  end
+end

data/lib/daemon_spawn.rb

@@ -0,0 +1,197 @@
+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.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
+      File.umask 0000
+      log = File.new(daemon.log_file, "a")
+      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("TERM", pid)
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+      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
+
+    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 + extension)
+      self.log_file = opts[:log_file] || File.join(working_dir, 'logs', app_name + '.log')
+      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?(self.pid_file)
+        begin
+          Process.kill(0, self.pid)
+        rescue Errno::ESRCH, ::Exception
+          false
+        end
+      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)
+      daemons = find(opts)
+      if daemons.empty?
+        daemons = build(opts)
+        daemons.map { |d| DaemonSpawn.start(d, args) }
+      else
+        puts "Daemons already started! PIDS: #{daemons.map {|d| d.pid}.join(', ')}"
+        exit 1
+      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 = find(opts)
+      daemons.map do |daemon|
+        DaemonSpawn.stop(daemon)
+        DaemonSpawn.start(daemon, args)
+      end
+    end
+  end
+end

data/test/daemon_spawn_test.rb

@@ -0,0 +1,102 @@
+require "socket"
+require "test/unit"
+
+class DaemonSpawnTest < Test::Unit::TestCase
+
+  SERVERS = File.join(File.dirname(__FILE__), "servers")
+
+  def with_socket
+    socket = TCPSocket.new('localhost', 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
+    Dir.chdir(SERVERS) do
+      `./echo_server.rb stop`
+      assert_match(/EchoServer started./, `./echo_server.rb start 5150`)
+      sleep 1
+      begin
+        with_socket
+      ensure
+        assert_match(//, `./echo_server.rb stop`)
+        assert_raises(Errno::ECONNREFUSED) { TCPSocket.new('localhost', 5150) }
+      end
+    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
+
+end

data/test/multi_daemon_spawn_test.rb

@@ -0,0 +1,111 @@
+require "test/unit"
+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/echo_server.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+
+require "daemon_spawn"
+require "socket"
+
+# 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 => '/tmp/echo_server.log',
+                  :pid_file => '/tmp/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)

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: seamusabshere-daemon-spawn
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 1
+  version: 0.2.1
+platform: ruby
+authors: 
+- Alex Vollmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: gem 0.3.0 re-release... originally at http://github.com/alexvollmer/daemon-spawn
+email: seamus@abshere.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- .autotest
+- .gitignore
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- VERSION
+- daemon-spawn.gemspec
+- 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
+has_rdoc: true
+homepage: http://github.com/seamusabshere/daemon-spawn
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A simple, flexible daemon management library. (re-released by Seamus Abshere)
+test_files: 
+- test/daemon_spawn_test.rb
+- test/multi_daemon_spawn_test.rb
+- test/servers/echo_server.rb
+- test/servers/simple_server.rb