wonko9-i_can_daemonize 0.0.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-07-09
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,58 @@
+.git/COMMIT_EDITMSG
+.git/FETCH_HEAD
+.git/HEAD
+.git/ORIG_HEAD
+.git/config
+.git/description
+.git/hooks/applypatch-msg
+.git/hooks/commit-msg
+.git/hooks/post-commit
+.git/hooks/post-receive
+.git/hooks/post-update
+.git/hooks/pre-applypatch
+.git/hooks/pre-commit
+.git/hooks/pre-rebase
+.git/hooks/prepare-commit-msg
+.git/hooks/update
+.git/index
+.git/info/exclude
+.git/logs/HEAD
+.git/logs/refs/heads/master
+.git/logs/refs/remotes/origin/HEAD
+.git/logs/refs/remotes/origin/master
+.git/objects/12/d7cbe8190afdd97a7a0859d9ce822ebc9846cd
+.git/objects/46/c5d39136616bca92118f3dbf16e474a9df7379
+.git/objects/4b/0480e9beae3ad3b1b17effeeaa1201560d7d02
+.git/objects/61/22343c51b970ba436bc47e3cf97f6221492291
+.git/objects/67/672462a81c734937a6b579751405f168e6fcb0
+.git/objects/69/69a6a4e8a6d185528b33de649ea3feb1516fb7
+.git/objects/6a/ddd18336cbaebdff0f727a06305c9232dbb058
+.git/objects/6c/eeb3df1cb65a06e0b434b7a78551d1d7c1c242
+.git/objects/73/ae5eefb32e4f335716aa281e9f78c3a61398b1
+.git/objects/8f/9c4a5a3c9a41935160b96fe005a54b3d3f18b2
+.git/objects/9c/878acd4b53fb8abaed6ba81ef78e2c3268c9f5
+.git/objects/a3/5a57b3e8003dcdd039a48441554799b417779d
+.git/objects/c3/d75d5327524a548ed2cfb997342b2107b83403
+.git/objects/cb/34e6ff08e94036d69d296284a62d723a2d8a90
+.git/objects/d4/b772650c4ad1378392aa5f2bb3c773a3818b73
+.git/objects/f5/9a3860619e3b9d956caa110ff00d0449977fea
+.git/objects/pack/pack-4efe288a1b0fd1df2942754b498c4480f00a7d52.idx
+.git/objects/pack/pack-4efe288a1b0fd1df2942754b498c4480f00a7d52.keep
+.git/objects/pack/pack-4efe288a1b0fd1df2942754b498c4480f00a7d52.pack
+.git/refs/heads/master
+.git/refs/remotes/origin/HEAD
+.git/refs/remotes/origin/master
+.gitignore
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/feature_demo.rb
+examples/rails_daemon.rb
+examples/simple_daemon.rb
+examples/starling_queue_daemon.rb
+lib/i_can_daemonize.rb
+lib/i_can_daemonize/version.rb
+test/simple_daemon.rb
+test/test_helper.rb
+test/test_i_can_daemonize.rb

data/README.txt

@@ -0,0 +1,99 @@
+= i_can_daemonize
+
+== DESCRIPTION:
+
+ICanDaemonize makes it dead simple to create daemons of your own.
+
+== REQUIREMENTS:
+
+* A Computer
+* Ruby
+
+== INSTALL:
+
+* Get ICanDaemonize off github
+
+== THE BASICS:
+
+  require 'rubygems'
+  require 'i_can_daemonize'
+  class MyDaemonClass
+    include ICanDaemonize
+    
+    daemonize do
+      # your code here
+    end
+    
+  end
+
+Run your daemon
+
+  ruby your_daemon_script start
+  
+ICD will create a log file in log/ called your_daemon_script.log as well as a pid file in log called your_daemon_script.pid
+
+It will essentially run the block given to daemonize within a loop.
+
+== USAGE:
+
+The daemonize method accepts a number of options see ICanDaemonize::ClassMethods daemonize() for options
+
+There are a number of other blocks you can define in your class as well, including:
+
+  before do/end
+
+  after do/end
+
+  die_if do/end
+
+  exit_if do/end
+
+See ICanDaemonize docs for more info on these options.
+
+Your daemon can be called with a number of options
+
+      --loop-every SECONDS         How long to sleep between each loop
+  -t, --ontop                      Stay on top (does not daemonize)
+      --instances=NUM              Allow multiple instances to run simultaneously? 0 for infinite. default: 1
+      --log-file=LOGFILE           Logfile to log to
+      --pid-file=PIDFILE           Directory to put pidfile
+  -h, --help                       Show this message
+
+You can add your own command line options by using the 'arg' class macro.  
+See http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html for more info on OptionParser.
+  
+  arg '--scott-rocks', 'Does scott rock?') do |value|
+    @scott_rocks = value
+  end
+  
+== BUGS:
+
+My method names may be too common to be included class methods
+
+ICanDaemonize attempts to capture all STDOUT or STDERR and prepend that output with a timestamp and PID.
+I don't like how this was implemented anyway. Feels dirty.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Adam Pisoni, Amos Elliston
+
+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,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rcov/rcovtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "i_can_daemonize"
+    s.summary = "ICanDaemonize makes it dead simple to create daemons of your own"
+    s.email = "wonko9@gmail.com"
+    s.homepage = "http://github.com/wonko9/i_can_daemonize"
+    s.description = "ICanDaemonize makes it dead simple to create daemons of your own"
+    s.authors = ["Adam Pisoni", "Amos Elliston"]
+    s.files =  FileList["[A-Z]*", "{lib,test}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/i_can_daemonize.rb

@@ -0,0 +1,482 @@
+require 'optparse'
+require 'timeout'    
+
+module ICanDaemonize
+  class DieTime < StandardError; end
+  class TimeoutError < StandardError; end
+
+  def self.included(base)
+    base.extend ClassMethods           
+    base.initialize_options
+  end
+
+  class Config
+    METHODS = [:script_path]
+    CONFIG = {}    
+    def method_missing(name, *args)
+      name = name.to_s.upcase.to_sym
+      if name.to_s =~ /^(.*)=$/
+        name = $1.to_sym
+        CONFIG[name] = args.first
+      else
+        CONFIG[name]
+      end
+    end    
+  end
+
+  module ClassMethods  
+    
+    def initialize_options    
+      @@config             = Config.new
+      @@config.script_path = File.expand_path(File.dirname($0))
+      $0                   = script_name
+    end
+    
+    def parse_options
+      opts = OptionParser.new do |opt|
+        opt.banner = "Usage: #{script_name} [options] [start|stop]"
+
+        opt.on_tail('-h', '--help', 'Show this message') do
+          puts opt
+          exit
+        end
+
+        opt.on('--loop-every=SECONDS', 'How long to sleep between each loop') do |value|
+          options[:loop_every] = value 
+        end
+
+        opt.on('-t', '--ontop', 'Stay on top (does not daemonize)') do
+          options[:ontop] = true
+        end
+
+        opt.on('--instances=NUM', 'Allow multiple instances to run simultaneously? 0 for infinite. default: 1') do |value|
+          self.instances = value.to_i
+        end
+
+        opt.on('--log-file=LOGFILE', 'Logfile to log to') do |value|
+          options[:log_file] = File.expand_path(value)
+        end
+
+        opt.on('--pid-file=PIDFILE', 'Location of pidfile') do |value|
+          options[:pid_file] = File.expand_path(value)
+        end
+
+        opt.on('--no-log-prefix', 'Do not prefix PID and date/time in log file.') do
+          options[:log_prefix] = false
+        end
+      end
+      
+      extra_args.each do |arg|
+        opts.on(*arg.first) do |value|
+          arg.last.call(value) if arg.last
+        end
+      end
+
+      opts.parse!
+      
+      if ARGV.include?('stop')                                                         
+        stop_daemons
+      elsif ARGV.include?('restart')
+        restart_daemons
+      elsif ARGV.include?('start') or ontop?
+        self.running   = true
+        self.restarted = true if ARGV.include?('HUP')
+      else
+        puts opts.help
+      end
+    end    
+
+    def arg(*args, &block)
+      self.extra_args << [args, block]
+    end
+
+    def extra_args
+      @extra_args ||= [] 
+    end
+
+    def callbacks
+      @callbacks ||= {}
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def config
+      yield @@config
+    end
+    
+    def before(&block)
+      callbacks[:before] = block
+    end
+
+    def after(&block)
+      callbacks[:after] = block
+    end
+
+    def sig(signal, &block)
+      callbacks["sig_#{signal}".to_sym] = block
+    end
+
+    def die_if(method=nil,&block)
+      options[:die_if] = method || block
+    end
+
+    def exit_if(method=nil,&block)
+      options[:exit_if] = method || block
+    end
+
+    def callback!(callback)
+      callbacks[callback].call if callbacks[callback]
+    end
+
+    # options may include:
+    #
+    # <tt>:loop_every</tt> Fixnum (DEFAULT 0)
+    #  How many seconds to sleep between calls to your block
+    #
+    # <tt>:timeout</tt> Fixnum (DEFAULT 0)
+    #  Timeout in if block does not execute withing passed number of seconds
+    #
+    # <tt>:die_on_timeout</tt> BOOL (DEFAULT False)
+    #  Should the daemon continue running if a block times out, or just run the block again
+    #
+    # <tt>:ontop</tt> BOOL (DEFAULT False)
+    #  Do not daemonize.  Run in current process
+    #
+    # <tt>:before</tt> BLOCK
+    #  Run this block after daemonizing but before begining the daemonize loop.
+    #  You can also define the before block by putting a before do/end block in your class.
+    #
+    # <tt>:after</tt> BLOCK
+    #  Run this block before program exists.  
+    #  You can also define the after block by putting an after do/end block in your class.
+    #
+    # <tt>:die_if</tt> BLOCK
+    #  Run this check after each iteration of the loop.   If the block returns true, throw a DieTime exception and exit
+    #  You can also define the after block by putting an die_if do/end block in your class.
+    #      
+    # <tt>:exit_if</tt> BLOCK
+    #  Run this check after each iteration of the loop.   If the block returns true, exit gracefully
+    #  You can also define the after block by putting an exit_if do/end block in your class.
+    #
+    # <tt>:log_prefix</tt> BOOL (DEFAULT true)
+    #  Prefix log file entries with PID and timestamp
+    def daemonize(opts={}, &block)
+      parse_options
+      return unless ok_to_start?
+
+      options.merge!(opts)
+      puts "Starting #{instances_to_start} #{script_name} #{pluarlize('instance', instances_to_start)}..."
+      puts "Logging to: #{log_file}" unless ontop?
+      
+      unless ontop?
+        instances_to_start.times do
+          safefork do
+            open(pid_file, 'a+') {|f| f << Process.pid << "\n"}
+            at_exit { remove_pid! }
+
+      
+            trap('TERM') { callback!(:sig_term) ; self.running = false     }
+            trap('INT')  { callback!(:sig_int)  ; Process.kill('TERM', $$) }
+            trap('HUP')  { callback!(:sig_hup)  ; restart_self             }
+
+            sess_id = Process.setsid
+            reopen_filehandes
+
+            begin
+              at_exit { callback!(:after) }
+              callback!(:before)
+              run_block(&block)
+            rescue SystemExit
+            rescue Exception => e
+              $stdout.puts "Something bad happened #{e.inspect} #{e.backtrace.join("\n")}"
+            end            
+          end
+        end
+      else
+        begin
+          callback!(:before)
+          run_block(&block)
+        rescue SystemExit, Interrupt
+          callback!(:after)
+        end
+      end
+    end
+
+    private
+    
+    def run_block(&block)
+      loop do
+        break unless running?
+        if options[:timeout]
+          begin
+            Timeout::timeout(options[:timeout].to_i) do
+              block.call if block              
+            end
+          rescue Timeout::Error => e
+            if options[:die_on_timeout]
+              raise TimeoutError.new("#{self} timed out after #{options[:timeout]} seconds while executing block in loop")
+            else
+              $stderr.puts "#{self} timed out after #{options[:timeout]} seconds while executing block in loop #{e.backtrace.join("\n")}"
+            end
+          end            
+        else
+          block.call if block
+          
+        end
+        if options[:loop_every]
+          sleep options[:loop_every].to_i
+        elsif not block
+          sleep 0.1
+        end
+        break if should_exit?
+        raise DieTime.new('Die if conditions were met!') if should_die?
+      end                    
+      exit(0)
+    end
+
+    def should_die?
+      die_if = options[:die_if]
+      if die_if
+        if die_if.is_a?(Symbol) or die_if.is_a?(String)
+          self.send(die_if)
+        elsif die_if.is_a?(Proc)
+          die_if.call
+        end
+      else
+        false
+      end
+    end
+
+    def should_exit?
+      exit_if = options[:exit_if]
+      if exit_if
+        if exit_if.is_a?(Symbol) or exit_if.is_a?(String)
+          self.send(exit_if.to_sym)
+        elsif exit_if.is_a?(Proc)
+          exit_if.call
+        end
+      else
+        false
+      end
+    end
+
+    def instances_to_start
+      return 1 if restarted?
+      instances - pids.size      
+    end
+
+    def ok_to_start?
+      return false unless running?
+      return true if restarted?
+
+      living_pids = []
+      if pids and pids.any?
+        pids.each do |pid|
+          if process_alive?(pid)                                                 
+            living_pids << pid
+          else
+            $stderr.puts "Removing stale pid: #{pid}..."
+            pids -= [pid]
+            self.pids = pids
+          end
+        end
+        if instances > 0 and living_pids.size >= instances
+          $stderr.puts "#{script_name} is already running #{living_pids.size} out of #{pluralize('instance', instances)}"
+          return false          
+        end
+      end
+      return true
+    end
+
+    # stop the daemon, nicely at first, and then forcefully if necessary
+    def stop_daemons
+      self.running = false      
+      puts "Stopping #{instances} #{script_name} #{pluarlize('instance', instances)}..."
+      if pids.empty?
+        $stderr.puts "#{script_name} doesn't appear to be running"
+        exit
+      end
+      pids.each_with_index do |pid, ii|
+        kill_pid(pid)
+        break if ii == (instances - 1)
+      end
+    end     
+
+    def restart_daemons
+      pids.each do |pid|
+        kill_pid(pid, 'HUP')
+      end
+    end
+    
+    def kill_pid(pid, signal='TERM')
+      $stdout.puts("Stopping pid #{pid} with #{signal}...")
+      begin
+        Process.kill(signal, pid)             
+        if pid_running?(pid, options[:timeout] || 120)
+          $stdout.puts("Using kill -9 #{pid}")
+          Process.kill(9, pid)
+        else
+          $stdout.puts("Process #{pid} stopped")
+        end
+      rescue Errno::ESRCH
+       $stdout.puts("Couldn't #{signal} #{pid} as it wasn't running")
+      end
+    end               
+    
+    def pid_running?(pid,time_to_wait=0)
+      times_to_check = 1
+      if time_to_wait > 0.5
+        times_to_check = (time_to_wait / 0.5).to_i
+      end
+            
+      begin
+        times_to_check.times do
+          Process.kill(0, pid)
+          sleep 0.5
+        end
+        return true
+      rescue Errno::ESRCH
+        return false
+      end      
+    end
+          
+    def restart_self
+      remove_pid!
+      cmd = "#{@@config.script_path}/#{script_name} "
+      cmd << 'HUP ' unless ARGV.include?('HUP')
+      cmd << ARGV.join(' ')
+      puts "Restarting #{cmd} pid: #{$$}..."
+      system(cmd)        
+      Process.kill('TERM', $$)
+    end
+        
+    def safefork(&block)
+      fork_tries ||= 0
+      fork(&block)
+    rescue Errno::EWOULDBLOCK
+      raise if fork_tries >= 20
+      fork_tries += 1
+      sleep 5
+      retry
+    end
+
+    def process_alive?(process_pid)
+      Process.kill(0, process_pid)
+      return true
+    rescue Errno::ESRCH => e
+      return false
+    end  
+
+    LOG_FORMAT  = '%-6d %-19s %s'
+    TIME_FORMAT = '%Y/%m/%d %H:%M:%S'
+    def reopen_filehandes
+      STDIN.reopen('/dev/null')
+      STDOUT.reopen(log_file, 'a')
+      STDOUT.sync = true          
+      STDERR.reopen(STDOUT)
+      if log_prefix?
+        def STDOUT.write(string)
+          if @no_prefix
+            @no_prefix = false if string[-1, 1] == "\n"
+          else
+            string = LOG_FORMAT % [$$, Time.now.strftime(TIME_FORMAT), string]
+            @no_prefix = true              
+          end
+          super(string)
+        end
+      end
+    end
+
+    def remove_pid!(pid=Process.pid)
+      pids.delete(pid)
+      self.pids = pids
+    end
+
+    def pids=(pids)
+      if pids.any?
+        open(pid_file, 'w') {|f| f << pids.join("\n") << "\n"}
+      else
+        File.unlink(pid_file) if File.exists?(pid_file)
+      end
+      @pids = pids
+    end
+
+    def pids
+      @pids ||= begin
+        if File.exist?(pid_file)
+          File.readlines(pid_file).collect {|p| p.to_i}
+        else
+          []
+        end
+      end
+    end
+
+    def instances=(num)
+      @instances = num
+    end
+
+    def instances
+      @instances ||= 1
+    end
+
+    def pluarlize(name, num)
+      num == 1 ? name : "#{name}s"
+    end
+
+    def running?
+      @running || false
+    end
+
+    def running=(bool)
+      @running = bool
+    end
+
+    def restarted?
+      @restarted || false
+    end
+
+    def restarted=(bool)
+      @restarted = bool
+    end
+
+    def ontop?
+      options[:ontop]
+    end
+
+    def log_prefix?
+      options[:log_prefix] || true
+    end                    
+    
+    LOG_PATHS = ['log/', 'logs/', '../log/', '../logs/', '../../log', '../../logs', '.']
+    LOG_PATHS.unshift("#{RAILS_ROOT}/log") if defined?(RAILS_ROOT)
+    def log_dir
+      options[:log_dir] ||= begin
+        LOG_PATHS.detect do |path|
+          File.exists?(File.expand_path(path))        
+        end
+      end               
+    end
+    
+    def log_file
+      options[:log_file] ||= File.expand_path("#{log_dir}/#{script_name}.log")
+    end
+
+    def pid_dir
+      options[:pid_dir] ||= log_dir
+    end
+
+    def pid_file
+      options[:pid_file] ||= File.expand_path("#{pid_dir}/#{script_name}.pid")
+    end
+
+    def script_name
+      @script_name ||= File.basename($0).gsub('.rb', '')
+    end
+
+    def script_name=(script_name)
+      @script_name = script_name
+    end
+  end
+end

data/test/simple_daemon.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../lib/i_can_daemonize'
+
+class SimpleDaemon
+  include ICanDaemonize
+
+  arg '--test=VALUE', 'Test Arg' do |value|
+    @test = value
+  end
+
+  arg '-s', '--short-test=VALUE', 'Test arg with shortname' do |value|
+    @short_test = value
+  end
+
+  counter = 0
+  daemonize do
+    if @options[:loop_every]
+      counter += 1
+      File.open(TEST_FILE, 'w'){|f| f << counter}
+    elsif @test
+      File.open(TEST_FILE, 'w'){|f| f << "#{@test}|#{@short_test}"}
+    else
+      File.open(TEST_FILE, 'w'){|f| f << "#{log_file}|#{pid_file}"}
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'pp'
+
+TEST_FILE = File.dirname(__FILE__) + '/test.txt' unless defined?(TEST_FILE)
+
+unless Test::Unit::TestCase.respond_to?(:test)
+  class << Test::Unit::TestCase
+    def test(name, &block)
+      test_name = "test_#{name.gsub(/[\s\W]/,'_')}"
+      raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include? test_name
+      define_method test_name, &block
+    end
+  end
+end

data/test/test_i_can_daemonize.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestICanDaemonize < Test::Unit::TestCase
+  DEFAULT_LOG_FILE = File.join(File.dirname(__FILE__), 'test_daemon.rb.log')
+
+  def setup
+    File.delete(TEST_FILE) if File.exist?(TEST_FILE)
+    @daemon = "#{File.dirname(__FILE__)}/simple_daemon.rb"
+  end
+
+  def teardown
+    File.delete(TEST_FILE) if File.exist?(TEST_FILE)
+    File.delete(DEFAULT_LOG_FILE) if File.exist?(DEFAULT_LOG_FILE)
+  end
+
+  test "passing options" do
+    log_file = File.expand_path(File.join(File.dirname(__FILE__), 'test.log'))
+    pid_file = File.expand_path(File.join(File.dirname(__FILE__), 'test.pid'))
+    `ruby #{@daemon} --log-file #{log_file} --pid-file #{pid_file} start`
+    `ruby #{@daemon} --log-file #{log_file} --pid-file #{pid_file} stop`
+    File.delete(log_file)
+    assert_equal "#{log_file}|#{pid_file}", File.read(TEST_FILE)
+  end
+  
+  test "loop every" do
+    `ruby #{@daemon} --loop-every 1 start`
+    sleep 5
+    `ruby #{@daemon} stop`
+    counter = File.read(TEST_FILE).to_i
+    assert counter > 5
+  end
+  
+  test "arg class macro" do
+    `ruby #{@daemon} --test test -s short-test start`
+    `ruby #{@daemon} stop`
+    assert_equal "test|short-test", File.read(TEST_FILE)
+  end
+
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: wonko9-i_can_daemonize
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Adam Pisoni
+- Amos Elliston
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: ICanDaemonize makes it dead simple to create daemons of your own
+email: wonko9@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- Rakefile
+- README.txt
+- lib/i_can_daemonize
+- lib/i_can_daemonize/version.rb
+- lib/i_can_daemonize.rb
+- test/simple_daemon.rb
+- test/test_helper.rb
+- test/test_i_can_daemonize.rb
+has_rdoc: true
+homepage: http://github.com/wonko9/i_can_daemonize
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ICanDaemonize makes it dead simple to create daemons of your own
+test_files: []
+