daemonic 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log/*.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in daemonic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+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/README.md

@@ -0,0 +1,100 @@
+# Daemonic
+
+Daemonic is a tool that let's you turn your long running processes into daemons.
+
+At a glance:
+
+* Designed to be external to and independent of your app.
+* Possibility to spawn multiple instances of your app.
+* Smart restart behavior, comparable to Unicorn.
+* Automatically restarts crashed instances of your app.
+
+### What can Daemonic do for me?
+
+Say you have written your own daemon. It processes messages of a queue for
+example. You can start it by running `ruby work.rb`. Now the only thing you
+need to do is turn it into a proper daemon. This means daemonizing your
+process, managing restarts, adding concurrency, managing a pid file, etc.
+
+This is a lot of work, quite error prone and frankly, very tedious. That's
+where Daemonic comes in. All you need to do, to start your message processor is:
+
+```
+$ daemonic --command "ruby work.rb" --pid work.pid --workers 5 --daemonize
+```
+
+And voila: you now have 5 instances of your worker, each in it's own process.
+This works just like Unicorn, but with any kind of process, not just Rack apps.
+You can restart all workers by sending the `USR2` signal, just like in Unicorn
+too.
+
+```
+$ kill -USR2 `cat work.pid`
+```
+
+This will restart each process individually, meaning you never lose capacity.
+
+There are some caveats though. For one, daemonic checks if the process is
+running, but it is very naive. It doesn't really know if the app is ready, just
+if it is running or not.
+
+Secondly, if your app needs a shared resource, spawning multiple workers will
+not work. This is the case with web servers that need to bind to a port.
+
+Also, your own worker needs to respond to the `TERM` and `HUP` signals.
+Daemonic expects the app to shut down after sending the `TERM` signal. It's up
+to you to finish up what you are doing.
+
+## Installation
+
+You don't need to add daemonic to your Gemfile. You can simply install it and
+use it straight away.
+
+```
+gem install daemonic
+```
+
+## Usage
+
+Daemonic accepts command line options and can also read from a configuration
+file. The configuration file contains the same options as you would pass to the
+command line. Here is an example:
+
+```
+--command "ruby work.rb"
+--workers 5
+--pid tmp/worker.pid
+--name my-worker
+--log log/development.log
+--daemonize
+```
+
+Then you can run Daemonic with the `config` option:
+
+```
+$ daemonic --config my-worker.conf
+```
+
+There are a bunch more options. See `daemonic --help` for the full list.
+
+### Signals
+
+These are the signals daemonic responds to:
+
+* `TERM`/`INT` shuts down all workers and then the master
+* `HUP` will be forwarded to each worker and the master will reload the config file
+* `USR2` will restart each worker, but not the master
+* `TTIN` increase the number of workers by one
+* `TTOU` decrease the number of workers by one
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## TODO
+
+* Ability to create init script like behavior.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+end
+
+task :default => :test

data/bin/daemonic

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'daemonic'
+
+config = Daemonic.configuration(ARGV, Dir.pwd)
+
+config.reload
+
+if config.daemonize?
+  Process.daemon
+end
+
+Daemonic.spawn(config)

data/daemonic.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'daemonic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "daemonic"
+  spec.version       = Daemonic::VERSION
+  spec.authors       = ["iain"]
+  spec.email         = ["iain@iain.nl"]
+  spec.description   = %q{Manages daemonizing your workers with basic monitoring and restart behavior.}
+  spec.summary       = %q{Manages daemonizing your workers with basic monitoring and restart behavior.}
+  spec.homepage      = "https://github.com/yourkarma/daemonic"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/daemonic/cli.rb

@@ -0,0 +1,68 @@
+require 'optparse'
+
+module Daemonic
+  module CLI
+
+    def self.parse(args)
+      options = {}
+
+      parser = OptionParser.new do |opts|
+
+        opts.banner = "Usage: #{$0} options"
+
+        opts.on("--command COMMAND", "The command to start") do |command|
+          options[:command] = command
+        end
+
+        opts.on("--[no-]daemonize", "Start process in background") do |daemonize|
+          options[:daemonize] = daemonize
+        end
+
+        opts.on("--workers NUM", Integer, "Amount of workers (default: 1)") do |workers|
+          options[:workers] = workers
+        end
+
+        opts.on("--pid FILENAME", "Location of pid files") do |pidfile|
+          options[:pidfile] = pidfile
+        end
+
+        opts.on("--working-dir DIRECTORY", "Specify the working directory") do |dir|
+          options[:working_dir] = dir
+        end
+
+        opts.on("--name NAME", "Name of the server") do |name|
+          options[:program_name] = name
+        end
+
+        opts.on("--log FILENAME", "Send daemon_of_the_fall output to a file") do |logfile|
+          options[:logfile] = logfile
+        end
+
+        opts.on("--loglevel LEVEL", [:debug, :info, :warn, :fatal], "Set the log level (default: info)") do |level|
+          options[:loglevel] = level
+        end
+
+        opts.on("--config FILENAME", "Read settings from a file") do |config_file|
+          options[:config_file] = config_file
+        end
+
+        opts.on_tail("--version", "Shows the version") do
+          require "daemonic/version"
+          puts "#{$0}: version #{Daemonic::VERSION}"
+          exit 0
+        end
+
+        opts.on_tail("--help", "You're watching it") do
+          puts opts
+          exit 0
+        end
+
+      end
+
+      parser.parse!(args.dup)
+
+      options
+    end
+
+  end
+end

data/lib/daemonic/configuration.rb

@@ -0,0 +1,114 @@
+require 'logger'
+require 'shellwords'
+
+module Daemonic
+  class Configuration
+
+    Invalid = Class.new(ArgumentError)
+
+    attr_reader :eventual_config, :args
+
+    def initialize(args, pwd)
+      @args = args
+      @pwd = pwd
+      @eventual_config = {}
+    end
+
+    def command
+      self[:command]
+    end
+
+    def daemonize?
+      self[:daemonize]
+    end
+
+    def config_file
+      self[:config_file]
+    end
+
+    def workers
+      Integer(self[:workers] || "1")
+    end
+
+    def reload
+      @eventual_config = {}
+      @logger = nil
+      load_options defaults
+      load_options command_line_options
+      load_options config_file_options if config_file
+      load_options command_line_options
+      logger.debug { to_h.inspect }
+      validate
+    end
+
+    def working_dir
+      self[:working_dir]
+    end
+
+    def program_name
+      self[:program_name] || File.basename(working_dir)
+    end
+
+    def pidfile
+      self[:pidfile] || File.join(working_dir, "tmp/#{program_name}.pid")
+    end
+
+    def logfile
+      self[:logfile] || STDOUT
+    end
+
+    def logger
+      @logger ||= ::Logger.new(logfile).tap { |logger|
+        logger.formatter = proc { |severity, datetime, progname, msg|
+          "[#{severity}] [#{datetime}] [#{program_name}] [#{Process.pid}] #{msg}\n"
+        }
+        logger.level = ::Logger.const_get(loglevel)
+      }
+    end
+
+    def to_h
+      eventual_config
+    end
+
+    def loglevel
+      (self[:loglevel] || "INFO").to_s.upcase
+    end
+
+    protected
+
+    def [](key)
+      eventual_config[key.to_s]
+    end
+
+    def []=(key, value)
+      eventual_config[key.to_s] = value
+    end
+
+    private
+
+    def load_options(options)
+      options.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def command_line_options
+      CLI.parse(args)
+    end
+
+    def config_file_options
+      contents = File.open(config_file, 'r:utf-8').read
+      args = Shellwords.split(contents)
+      CLI.parse(args)
+    end
+
+    def validate
+      raise Invalid, "No command specified" if command.nil?
+    end
+
+    def defaults
+      { :workers => 1, :working_dir => @pwd }
+    end
+
+  end
+end

data/lib/daemonic/logging.rb

@@ -0,0 +1,14 @@
+require 'forwardable'
+
+module Daemonic
+  module Logging
+    extend Forwardable
+
+    def_delegators :logger, :info, :debug, :warn, :fatal
+
+    def logger
+      config.logger
+    end
+
+  end
+end

data/lib/daemonic/master.rb

@@ -0,0 +1,119 @@
+require 'thread'
+require 'daemonic/version'
+require 'daemonic/logging'
+require 'daemonic/pidfile'
+
+Thread.abort_on_exception = true
+
+module Daemonic
+  class Master
+    include Logging
+
+    attr_reader :config, :pidfile
+
+    def initialize(config)
+      @config = config
+      @shutting_down = false
+      @current_status = nil
+      config.reload
+      update_program_name("booting")
+      @pidfile = Pidfile.new(
+        pid:       Process.pid,
+        config:    config,
+      )
+    end
+
+    def start
+      Dir.chdir(config.working_dir)
+      write_pidfile
+      at_exit { clean_pidfile }
+      trap_signals
+      start_workers
+      update_program_name(nil)
+      wait_until_done
+      update_program_name
+      fatal "Shutting down master"
+    end
+
+    def restart
+      @monitor = false
+      update_program_name("restarting")
+      pool.restart { update_program_name }
+      update_program_name(nil)
+      @monitor = true
+    end
+
+    def stop
+      @monitor = false
+      update_program_name("shutting down")
+      pool.stop { update_program_name }
+      @shutting_down = true
+    end
+
+    def hup
+      config.reload
+      pool.start
+      pool.hup
+    end
+
+    private
+
+    def write_pidfile
+      pidfile.write
+    end
+
+    def clean_pidfile
+      pidfile.clean
+    end
+
+    def start_workers
+      pool.start { update_program_name }
+      @monitor = true
+    end
+
+    def pool
+      @pool ||= Pool.new(config)
+    end
+
+    def trap_signals
+      trap("USR2") { info "USR2 received!"; restart }
+      trap("TERM") { info "TERM received!"; stop }
+      trap("INT")  { info "INT received!";  stop }
+      trap("HUP")  { info "HUP received!";  hup }
+      trap("TTIN") { info "TTIN received!"; ttin }
+      trap("TTOU") { info "TTOU received!"; ttou }
+    end
+
+    def ttin
+      pool.increase!
+    end
+
+    def ttou
+      pool.decrease!
+    end
+
+    def wait_until_done
+      while keep_running?
+        pool.monitor if @monitor
+        update_program_name
+        sleep 0.1
+      end
+    end
+
+    def keep_running?
+      not @shutting_down
+    end
+
+    def update_program_name(additional = :unchanged)
+      @current_status = additional if additional != :unchanged
+      base = "#{config.program_name} master [version #{VERSION}; #{pool.count}/#{pool.desired_workers} workers]"
+      if @current_status
+        $PROGRAM_NAME = "#{base} (#{@current_status})"
+      else
+        $PROGRAM_NAME = base
+      end
+      $PROGRAM_NAME
+    end
+
+  end
+end

data/lib/daemonic/pidfile.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+
+module Daemonic
+  class Pidfile
+    include FileUtils
+    include Logging
+
+    attr_reader :pid, :config, :index
+
+    def initialize(options = {})
+      @pid      = options.fetch(:pid)
+      @config   = options.fetch(:config)
+      @index    = options[:index]
+    end
+
+    def write
+      mkdir_p(File.dirname(filename))
+
+      if File.exist?(filename)
+        existing_pid = File.open(filename, 'r').read.chomp
+        running = Process.getpgid(existing_pid) rescue false
+        if running
+          fatal "Error: PID file already exists at `#{filename}` and a process with PID `#{existing_pid}` is running"
+          exit 1
+        else
+          debug "Warning: cleaning up stale pid file at `#{filename}`"
+          write!
+        end
+      else
+        debug "Writing pidfile #{filename} with pid #{pid}"
+        write!
+      end
+    end
+
+    def clean
+      if File.exist?(filename)
+        existing_pid = File.open(filename, 'r').read.chomp
+        if existing_pid == pid.to_s
+          debug "Cleaning up my own pid file at `#{filename}`"
+          rm(filename)
+        else
+          debug "Pid file `#{filename}` did not belong to me, so not cleaning. I am #{Process.pid}, and the pid file says #{existing_pid}"
+        end
+      else
+        debug "Pid file disappeared from `#{filename}`"
+      end
+    end
+
+    private
+
+    def filename
+      if index
+        config.pidfile.to_s.sub(/\.([^\.]+)\z/, ".#{index}.\\1")
+      else
+        config.pidfile
+      end
+    end
+
+    def write!
+      File.open(filename, 'w') { |f| f.write(pid) }
+    end
+
+  end
+end

data/lib/daemonic/pool.rb

@@ -0,0 +1,104 @@
+require 'daemonic/logging'
+require 'daemonic/worker'
+
+module Daemonic
+  class Pool
+    include Logging
+
+    attr_reader :config
+
+    attr_reader :workers, :desired_workers
+
+    def initialize(config)
+      @config = config
+      @workers = []
+      reload_desired_workers
+    end
+
+    def start
+      wait_for global_timeout do
+        increase if count < desired_workers
+        count == desired_workers
+      end
+      decrease while count > desired_workers
+    end
+
+    def restart
+      workers.each do |worker|
+        worker.restart
+        yield worker if block_given?
+      end
+    end
+
+    def stop
+      workers.each do |worker|
+        worker.stop
+        yield worker if block_given?
+      end
+    end
+
+    def hup
+      reload_desired_workers
+      workers.each(&:hup)
+      start
+    end
+
+    def count
+      workers.count { |worker| worker.running? }
+    end
+
+    def increase
+      workers << start_worker(workers.size)
+    end
+
+    def increase!
+      @desired_workers += 1
+      increase
+    end
+
+    def decrease
+      workers.pop.stop
+    end
+
+    def decrease!
+      @desired_workers -= 1
+      decrease
+    end
+
+    def monitor
+      workers.each(&:monitor)
+    end
+
+    private
+
+    def start_worker(num)
+      Worker.new(
+        index:  num,
+        config: config,
+      ).tap(&:start)
+    end
+
+    def reload_desired_workers
+      @desired_workers = config.workers
+    end
+
+    def global_timeout
+      (desired_workers * 2) + 1
+    end
+
+    def wait_for(timeout=2)
+      deadline = Time.now + timeout
+      until Time.now >= deadline
+        result = yield
+        if result
+          return
+        else
+          sleep 0.1
+        end
+      end
+      fatal "Unable to get to boot the right amount of workers. Running: #{count}, desired: #{desired_workers}."
+      stop
+      exit 1
+    end
+  end
+end

data/lib/daemonic/version.rb

@@ -0,0 +1,3 @@
+module Daemonic
+  VERSION = "0.0.1"
+end

data/lib/daemonic/worker.rb

@@ -0,0 +1,93 @@
+module Daemonic
+  class Worker
+    include Logging
+
+    attr_reader :index, :config
+
+    def initialize(options)
+      @index        = options.fetch(:index)
+      @config       = options.fetch(:config)
+    end
+
+    def start
+      @pid = Process.spawn(
+        {"DAEMON_WORKER_NUMBER" => index.to_s},
+        *Array(config.command),
+        {:chdir => config.working_dir}
+      )
+      sleep 0.1
+      info "#{to_s} Starting."
+      pidfile.write
+      wait_for { running? }
+      info "#{to_s} Started!"
+    end
+
+    def stop
+      Process.kill("TERM", pid)
+      info "#{to_s} Stopping."
+      Process.waitpid(pid)
+    rescue Errno::ECHILD, Errno::ESRCH
+      warn "#{to_s} Already stopped."
+    ensure
+      pidfile.clean
+      @pid = nil
+    end
+
+    def restart
+      info "#{to_s} Restarting."
+      stop
+      start
+    end
+
+    def hup
+      Process.kill("HUP", pid)
+    end
+
+    def monitor
+      if not running?
+        warn "#{to_s} Not running."
+        start
+      end
+    end
+
+    def running?
+      if @pid
+        !Process.waitpid(pid, Process::WNOHANG) rescue false
+      else
+        false
+      end
+    end
+
+    private
+
+    def pid
+      @pid || raise("unknown pid")
+    end
+
+    def pidfile
+      Pidfile.new(
+        pid:       pid,
+        config:    config,
+        index:     index,
+      )
+    end
+
+    def wait_for(timeout=2)
+      deadline = Time.now + timeout
+      until Time.now >= deadline
+        result = yield
+        if result
+          return
+        else
+          sleep 0.1
+        end
+      end
+      warn "#{to_s} It took too long to start."
+    end
+
+    def to_s
+      "<Worker:#{index} pid:#{@pid.inspect} running:#{running?.inspect}>"
+    end
+
+  end
+end

data/lib/daemonic.rb

@@ -0,0 +1,17 @@
+require "daemonic/version"
+require "daemonic/master"
+require "daemonic/pool"
+require "daemonic/configuration"
+require "daemonic/cli"
+
+module Daemonic
+
+  def self.spawn(*args)
+    Master.new(*args).start
+  end
+
+  def self.configuration(*args)
+    Configuration.new(*args)
+  end
+
+end

data/test/config

@@ -0,0 +1,6 @@
+--workers 5
+--pid tmp/test.pid
+--name daemon_test
+--command "ruby test/test_daemon.rb"
+--loglevel debug
+--log log/test.log

data/test/crappy_daemon.rb

@@ -0,0 +1 @@
+exit 1

data/test/integration_test.rb

@@ -0,0 +1,138 @@
+require 'minitest/autorun'
+require "thread"
+
+class TestIntegration < MiniTest::Unit::TestCase
+
+  def test_integration
+    master_pid = daemonic %Q|--workers 5 --pid tmp/test.pid --name daemon-test --command "ruby test/test_daemon.rb" --log #{LOGFILE}|
+    perform_tests(master_pid)
+  end
+
+  def test_with_config_file
+    master_pid = daemonic %Q|--config test/config|
+    perform_tests(master_pid)
+  end
+
+  def test_with_failing_daemon
+    master_pid = daemonic %Q|--pid tmp/test.pid --name daemon-test --command "ruby test/crappy_daemon.rb" --log #{LOGFILE}|
+    sleep 0.2
+    wait_for(10) { not running? master_pid }
+  end
+
+  def setup
+    FileUtils.mkdir_p(File.dirname(LOGFILE))
+    FileUtils.rm(LOGFILE) if File.exist?(LOGFILE)
+  end
+
+  def teardown
+    spawned_commands.each { |pid| Process.kill("TERM", pid) }
+  end
+
+  private
+
+  def running?(pid)
+    Process.getpgid(pid) rescue false
+  end
+
+  def perform_tests(master_pid)
+
+    pids_of_workers = []
+    wait_for {
+      pids_of_workers = find_worker_pids
+      pids_of_workers.size == 5
+    }
+
+    sleep 1
+
+    # restart
+    signal "USR2", master_pid
+
+    sleep 1
+
+    wait_for {
+      new_pids_of_workers = find_worker_pids
+      all_are_different?(new_pids_of_workers, pids_of_workers)
+    }
+    assert_equal 5, find_worker_pids.size
+
+    # master pid file
+    file = "tmp/test.pid"
+    assert File.exist?(file), "Missing master pidfile at #{file}"
+
+    # worker pid files
+    (0...5).each do |num|
+      file = "tmp/test.#{num}.pid"
+      assert File.exist?(file), "Missing worker pidfile at #{file}"
+    end
+
+    # increase workers on the fly
+    signal "TTIN", master_pid
+    assert_equal 6, find_worker_pids.size
+
+    # decrease workers on the fly
+    signal "TTOU", master_pid
+    assert_equal 5, find_worker_pids.size
+
+    # monitor crashing workers
+    pid_to_kill = find_worker_pids.first
+    signal "TERM", pid_to_kill
+    sleep 0.2
+    assert_equal 5, find_worker_pids.size
+
+    # shutdown
+    signal "TERM", master_pid
+    workers_remaining = []
+    wait_for {
+      workers_remaining = find_worker_pids
+      workers_remaining.size == 0
+    }
+  end
+
+  SCRIPT_NAME = "test_daemon.rb"
+  LOGFILE = "log/test.log"
+
+  def spawned_commands
+    @spawned_commands ||= []
+  end
+
+  def find_worker_pids
+    find_pids_for(SCRIPT_NAME)
+  end
+
+  def daemonic(command)
+    cmd = "./bin/daemonic #{command}"
+    puts "\n#{cmd}"
+    pid = spawn(cmd)
+    spawned_commands << pid
+    pid
+  end
+
+  def find_pids_for(filter)
+    processes = `ps u`.split("\n")
+    found = processes.select { |line| line.include?(filter) }
+    found.map { |line| line.split(/\s+/, 4)[1].to_i }
+  end
+
+  def signal(type, pid)
+    Process.kill(type, pid)
+    sleep 0.1
+  end
+
+  def wait_for(timeout=10)
+    deadline = Time.now + timeout
+    until Time.now >= deadline
+      result = yield
+      if result
+        return
+      else
+        sleep 0.1
+      end
+    end
+    raise "Timeout expired, running now: #{find_worker_pids.inspect}"
+  end
+
+  def all_are_different?(one, two)
+    (one & two).empty?
+  end
+
+end

data/test/test_daemon.rb

@@ -0,0 +1,10 @@
+exiting = false
+trap("TERM") { exiting = true }
+trap("INT") { exiting = true }
+trap("HUP") { puts "HUP HOLLAND HUP" }
+
+$PROGRAM_NAME = "test_daemon.rb daemon_test worker##{ENV["DAEMON_WORKER_NUMBER"]}"
+
+until exiting
+  sleep 0.1
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: daemonic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- iain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manages daemonizing your workers with basic monitoring and restart behavior.
+email:
+- iain@iain.nl
+executables:
+- daemonic
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/daemonic
+- daemonic.gemspec
+- lib/daemonic.rb
+- lib/daemonic/cli.rb
+- lib/daemonic/configuration.rb
+- lib/daemonic/logging.rb
+- lib/daemonic/master.rb
+- lib/daemonic/pidfile.rb
+- lib/daemonic/pool.rb
+- lib/daemonic/version.rb
+- lib/daemonic/worker.rb
+- test/config
+- test/crappy_daemon.rb
+- test/integration_test.rb
+- test/test_daemon.rb
+homepage: https://github.com/yourkarma/daemonic
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Manages daemonizing your workers with basic monitoring and restart behavior.
+test_files:
+- test/config
+- test/crappy_daemon.rb
+- test/integration_test.rb
+- test/test_daemon.rb