daemon-spawn 0.2.0

data/History.txt

@@ -0,0 +1,11 @@
+=== 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,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/daemon-spawn.rb
+test/test_daemon-spawn.rb
+examples/echo_server.rb

data/README.txt

@@ -0,0 +1,98 @@
+= 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.
+
+See the <tt>examples</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!
+
+== 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,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/daemon-spawn.rb'
+
+Hoe.spec('daemon-spawn') do |p|
+  p.developer('Alex Vollmer', 'alex.vollmer@gmail.com')
+  p.rubyforge_name = 'daemon-spawn'
+end
+
+# vim: syntax=Ruby

data/examples/echo_server.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require "socket"
+require "rubygems"
+require "daemon-spawn"
+
+# 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)
+    port = self.server_socket.addr[1]
+    puts "EchoServer started on port #{port}"
+    loop do
+      begin
+        client = self.server_socket.accept
+        while str = client.gets
+          client.write(str)
+        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/lib/daemon-spawn.rb

@@ -0,0 +1,158 @@
+require "fileutils"
+
+# Large portions of this were liberally stolen from the
+# 'simple-daemon' project at http://simple-daemon.rubyforge.org/
+module DaemonSpawn
+  VERSION = '0.2.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 log file to #{daemon.pid_file}"
+      exit 1
+    end
+
+    if daemon.alive? && daemon.singleton
+      STDERR.puts "An instance of #{daemon.classname} is already " +
+        "running (PID #{daemon.pid})"
+      exit 1
+    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.classname} 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?"
+      exit
+    end
+  rescue Errno::ESRCH
+    puts "Pid file found, but process was not running. The daemon may have died."
+  end
+
+  def self.status(daemon) #:nodoc:
+    if daemon.alive?
+      puts "#{daemon.classname} is running (PID #{PidFile.recall(daemon)})"
+    else
+      puts "#{daemon.classname} is NOT running"
+    end
+  end
+
+  class Base
+    attr_accessor :log_file, :pid_file, :sync_log, :working_dir, :singleton
+
+    def initialize(opts={ })
+      raise "You must specify a :working_dir" unless opts[:working_dir]
+      self.working_dir = opts[:working_dir]
+
+      self.log_file = opts[:log_file] || File.join(self.working_dir, 'logs', self.classname + '.log')
+      self.pid_file = opts[:pid_file] || File.join(self.working_dir, 'run', self.classname + '.pid')
+      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
+
+    # 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.size > 0 && args.shift
+      when 'start'
+        daemon = self.new(opts)
+        DaemonSpawn.start(daemon, args)
+      when 'stop'
+        daemon = self.new(opts)
+        DaemonSpawn.stop(daemon)
+      when 'status'
+        daemon = self.new(opts)
+        if daemon.alive?
+          puts "#{daemon.classname} is running (#{daemon.pid})"
+        else
+          puts "#{daemon.classname} is NOT running"
+        end
+      when 'restart'
+        daemon = self.new(opts)
+        DaemonSpawn.stop(daemon)
+        DaemonSpawn.start(daemon, args)
+      when '-h', '--help', 'help'
+        DaemonSpawn.usage
+        exit
+      else
+        DaemonSpawn.usage "Invalid command"
+        exit 1
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: daemon-spawn
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Alex Vollmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-01 01:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+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).
+email: 
+- alex.vollmer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/daemon-spawn.rb
+- test/test_daemon-spawn.rb
+- examples/echo_server.rb
+has_rdoc: true
+homepage: http://github.com/alexvollmer/daemon-spawn
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: daemon-spawn
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Daemon launching and management made dead simple
+test_files: 
+- test/test_daemon-spawn.rb