daemonizer 0.0.1 → 0.0.2

data/README

@@ -0,0 +1,48 @@
+engine :fork 
+workers 2
+
+pool :daemonizer do
+  workers 4
+  poll_period 5
+  log_file "log/daemonizer.log" #relative to Demfile
+  
+  before_init do |logger, block|
+    block.call
+  end
+  
+  after_init do |logger, worker_id, workers_count|
+    logger.info "Started #{worker_id} from #{workers_count}"
+    
+    exit = false
+    
+    stop = proc {
+      exit = true
+    }
+
+    trap('TERM', stop)
+    trap('INT', stop)
+    trap('EXIT', stop)
+    
+    loop do
+      break if exit
+      logger.info "Ping #{worker_id}"
+      sleep 10
+    end
+    
+    true
+  end
+end
+
+pool :new_daemonizer do
+
+  before_init do |logger, block|
+    logger.info "New: Preparing master process"
+    block.call
+  end
+  
+  after_init do |logger, worker_id, workers_count|
+    logger.info "Started #{worker_id}/#{workers_count}"
+    sleep 1
+    logger.info "Stopped #{worker_id}/#{workers_count}"
+  end
+end

data/Rakefile

@@ -1,14 +1,32 @@
+require 'rubygems'
+require 'rubygems/specification'
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "daemonizer"
     gemspec.summary = "Daemonizer allows you to easily create custom daemons on ruby. Supporting preforked and threaded models."
-    gemspec.description = "Inspired by bundler. Mostly build on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops"
+    gemspec.description = "Inspired by bundler and rack. Mostly built on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops"
     gemspec.email = "glebpom@gmail.com"
     gemspec.homepage = "http://github.com/glebpom/daemonizer"
     gemspec.authors = ["Gleb Pomykalov"]
+    gemspec.add_dependency('log4r', '>= 1.1.8')
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: gem install jeweler"
-end
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new(:yard) do |t|
+    t.options = ['--title', 'Daemonizer Documentation']
+    if ENV['PRIVATE']
+      t.options.concat ['--protected', '--private']
+    else
+      t.options.concat ['--protected', '--no-private']
+    end
+  end
+rescue LoadError
+  puts 'Yard not available. Install it with: sudo gem install yard'
+end

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/bin/daemonizer

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require File.dirname(__FILE__) + '/../lib/daemonizer'
+
+$thor_runner = false 
+
+Daemonizer::CLI.start

data/daemonizer.gemspec

@@ -0,0 +1,57 @@
+# 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{daemonizer}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gleb Pomykalov"]
+  s.date = %q{2010-07-06}
+  s.default_executable = %q{daemonizer}
+  s.description = %q{Inspired by bundler and rack. Mostly built on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops}
+  s.email = %q{glebpom@gmail.com}
+  s.executables = ["daemonizer"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "VERSION",
+     "bin/daemonizer",
+     "daemonizer.gemspec",
+     "lib/daemonizer.rb",
+     "lib/daemonizer/autoload.rb",
+     "lib/daemonizer/cli.rb",
+     "lib/daemonizer/config.rb",
+     "lib/daemonizer/daemonize.rb",
+     "lib/daemonizer/dsl.rb",
+     "lib/daemonizer/engine.rb",
+     "lib/daemonizer/errors.rb",
+     "lib/daemonizer/process_manager.rb",
+     "lib/daemonizer/worker.rb",
+     "lib/daemonizer/worker_pool.rb"
+  ]
+  s.homepage = %q{http://github.com/glebpom/daemonizer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Daemonizer allows you to easily create custom daemons on ruby. Supporting preforked and threaded models.}
+
+  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
+      s.add_runtime_dependency(%q<log4r>, [">= 1.1.8"])
+    else
+      s.add_dependency(%q<log4r>, [">= 1.1.8"])
+    end
+  else
+    s.add_dependency(%q<log4r>, [">= 1.1.8"])
+  end
+end
+

data/lib/daemonizer.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'yaml'
+require 'erb'
+require 'pathname'
+require 'log4r'
+
+include Log4r
+
+module Daemonizer
+  
+  def self.root=(value)
+    @@root = value
+  end
+
+  def self.root
+    @@root
+  end
+
+end
+
+require File.dirname(__FILE__) + '/../lib/daemonizer/autoload'

data/lib/daemonizer/autoload.rb

@@ -0,0 +1,16 @@
+module Daemonizer
+  # @private
+  def self.__p(*path) File.join(File.dirname(File.expand_path(__FILE__)), *path) end
+
+  autoload :Config,         __p('config')
+  autoload :Dsl,            __p('dsl')
+  autoload :Errors,         __p('errors')
+  autoload :CLI,            __p('cli')
+  autoload :Daemonize,      __p('daemonize')
+  autoload :Engine,         __p('engine')
+  autoload :Worker,         __p('worker')
+  autoload :WorkerPool,     __p('worker_pool')
+  autoload :ProcessManager, __p('process_manager')
+
+  include Errors
+end

data/lib/daemonizer/cli.rb

@@ -0,0 +1,115 @@
+require 'thor'
+require 'rubygems/config_file'
+
+module Daemonizer  
+  class CLI < Thor
+    check_unknown_options!
+
+    def initialize(*)
+      super
+    end
+                
+    desc "start", "Start pool"
+    method_option :demfile, :type => :string, :aliases => "-D", :banner => "Path to Demfile"
+    def start(pool_name = nil)
+      control_pools_loop(pool_name, "successfully started", options[:demfile]) do |pool|
+        # Pid file check
+        if Daemonize.check_pid(pool.pid_file)
+          print_pool pool.name,  "Can't start, another process exists!"
+          exit(1)
+        end
+
+        print_pool pool.name,  "Starting pool"
+
+        app_name = "#{pool.name} monitor\0"
+        
+        Daemonize.daemonize(app_name)
+
+        Dir.chdir(Daemonizer.root) # Make sure we're in the working directory
+
+        # Pid file creation
+        Daemonize.create_pid(pool.pid_file)
+
+        # Workers processing
+        engine = Engine.new(pool)
+        engine.start!
+
+        # Workers exited, cleaning up
+        File.delete(pool.pid_file) rescue nil
+      end
+      return true
+    end
+    
+    desc "stop", "Stop pool"
+    method_option :demfile, :type => :string, :aliases => "-D", :banner => "Path to Demfile"
+    def stop(pool_name = nil)
+      control_pools_loop(pool_name, "successfully stoped", options[:demfile]) do |pool|
+        STDOUT.sync = true
+        unless Daemonize.check_pid(pool.pid_file)
+          print_pool pool.name, "No pid file or a stale pid file!"
+          exit 1
+        end
+
+        pid = Daemonize.read_pid(pool.pid_file)
+        print_pool pool.name,  "Killing the process: #{pid}: "
+
+        loop do
+          Process.kill('SIGTERM', pid)
+          sleep(1)
+          break unless Daemonize.check_pid(pool.pid_file)
+        end
+
+        print_pool pool.name,  " Done!"
+        exit(0)
+      end
+      return true
+    end
+
+    desc "restart", "Restart pool"
+    def restart(pool_name = nil)
+      invoke :stop, pool_name
+      invoke :start, pool_name
+    end
+
+    desc "status", "Print pool status"
+    def status(pool_name = nil)
+      return true
+    end
+    
+  private
+    def control_pools_loop(pool_name, message = nil, demfile = nil, &block)
+      find_pools(pool_name, demfile).each do |pool|
+        Process.fork do
+          yield(pool)
+        end
+        Process.wait
+        if $?.exitstatus == 0 and message
+          print_pool pool.name, message 
+        end
+      end
+    end
+    
+    def find_pools(pool_name, demfile)
+      demfile_name = demfile || "Demfile"
+      
+      Daemonizer.root = File.dirname(File.expand_path(demfile_name))
+      
+      pools = Dsl.evaluate(demfile_name)
+      
+      if pool_name
+        if pool = pools[pool_name.to_sym]
+          [pool]
+        else
+          print_pool pool_name,  "Pool with name `#{pool_name}` is not configured"
+          []
+        end
+      else
+        pools.values
+      end
+    end
+    
+    def print_pool(pool_name, message)
+      puts "#{pool_name}: #{message}"
+    end
+  end
+end

data/lib/daemonizer/config.rb

@@ -0,0 +1,65 @@
+module Daemonizer
+  class Config
+    class ConfigError < StandardError;  end
+
+    attr_reader :pool
+
+    def initialize(pool, options)
+      @pool = pool
+      @options = options
+      init_defaults
+      init_logger
+      validate
+    end
+    
+    def init_logger
+      @logger = Logger.new @pool.to_s
+      outputter = FileOutputter.new('log', :filename => self.log_file)
+      outputter.formatter = PatternFormatter.new :pattern => "%d - %l %g - %m"
+      @logger.outputters = outputter
+      @logger.level = INFO
+      GDC.set "#{Process.pid}/monitor"
+    end
+    
+    def init_defaults
+      @options[:before_init] ||= Proc.new
+      @options[:engine] ||= :fork
+      @options[:workers] ||= 1
+      @options[:log_file] ||= "log/#{@pool}.log"
+      @options[:poll_period] ||= 5
+      @options[:pid_file] ||= "pid/#{@pool}.pid"
+    end
+    
+    def validate
+      Daemonizer.report_fatal_error "Workers count should be more then zero", @logger if @options[:workers] < 1
+      Daemonizer.report_fatal_error "Engine #{@options[:engine]} is not known", @logger unless [:fork, :thread].include?(@options[:engine])
+      if @options[:before_init]
+        Daemonizer.report_fatal_error "before_init should have block", @logger unless @options[:before_init].is_a?(Proc)
+      end
+      Daemonizer.report_fatal_error "after_init should be set", @logger if @options[:after_init].nil?
+      Daemonizer.report_fatal_error "after_init should have block", @logger unless @options[:after_init].is_a?(Proc)
+      Daemonizer.report_fatal_error "Poll period should be more then zero", @logger if @options[:poll_period] < 1
+    end
+    
+    [:before_init, :engine, :workers, :after_init, :poll_period, :root].each do |method|
+      define_method method do
+        @options[method.to_sym]
+      end
+    end
+        
+    [:log_file, :pid_file].each do |method|
+      define_method method do
+        File.join(Daemonizer.root, @options[method.to_sym])
+      end
+    end
+    
+    def name
+      @pool
+    end
+    
+    def logger
+      @logger
+    end
+  end
+
+end

data/lib/daemonizer/daemonize.rb

@@ -0,0 +1,67 @@
+module Daemonizer
+  module Daemonize
+    def self.read_pid(pid_file)
+      File.open(pid_file) do |f|
+        f.gets.to_i
+      end
+    rescue Errno::ENOENT
+      0
+    end
+
+    def self.check_pid(pid_file)
+      pid = read_pid(pid_file)
+      return false if pid.zero?
+      if defined?(::JRuby)
+        system "kill -0 #{pid} &> /dev/null"
+        return $? == 0
+      else
+        Process.kill(0, pid)
+      end
+      true
+    rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM
+      false
+    end
+
+    def self.create_pid(pid_file)
+      if File.exist?(pid_file)
+        puts "Pid file #{pid_file} exists! Checking the process..."
+        if check_pid(pid_file)
+          puts "Can't create new pid file because another process is runnig!"
+          return false
+        end
+        puts "Stale pid file! Removing..."
+        File.delete(pid_file)
+      end
+
+      File.open(pid_file, 'w') do |f|
+        f.puts(Process.pid)
+      end
+
+      return true
+    end
+
+    def self.daemonize(app_name)
+      if defined?(::JRuby)
+        puts "WARNING: daemonize method is not implemented for JRuby (yet), please consider using nohup."
+        return
+      end
+
+      fork && exit # Fork and exit from the parent
+
+      # Detach from the controlling terminal
+      unless sess_id = Process.setsid
+        raise Daemons.RuntimeException.new('cannot detach from controlling terminal')
+      end
+
+      # Prevent the possibility of acquiring a controlling terminal
+      trap 'SIGHUP', 'IGNORE'
+      exit if pid = fork
+
+      $0 = app_name if app_name
+      
+      File.umask(0000) # Insure sensible umask
+
+      return sess_id
+    end
+  end
+end

data/lib/daemonizer/dsl.rb

@@ -0,0 +1,58 @@
+module Daemonizer
+  class DslError < StandardError; end
+
+  class Dsl
+    def self.evaluate(gemfile)
+      builder = new
+      builder.instance_eval(File.read(gemfile.to_s), gemfile.to_s, 1)
+      builder.instance_variable_get("@configs")
+    end
+
+    def initialize
+      @source   = nil
+      @options  = {}
+      @pool     = :default
+      @configs  = {}
+    end
+        
+    def poll_period(seconds)
+      @options[:poll_period] = seconds.to_i
+    end
+    
+    def log_file(log)
+      @options[:log_file] = log
+    end
+    
+    def workers(num)
+      @options[:workers] = num.to_i
+    end
+    
+    def engine(name)
+      @options[:engine] = name.to_sym
+    end
+    
+    def before_init(&blk)
+      @options[:before_init] = blk
+    end
+    
+    def after_init(&blk)
+      @options[:after_init] = blk
+    end
+    
+    def pid_file(pid)
+      @options[:pid_file] = pid
+    end
+
+    def pool(name, &blk)
+      @pool = name.to_sym
+      options = @options.dup
+      yield
+      @configs[@pool] = Config.new(@pool, @options)
+    rescue Config::ConfigError => e
+      puts "* Error in pool \"#{@pool}\": #{e.to_s}. Skipping..."
+    ensure
+      @options = options
+      @pool = nil
+    end
+  end
+end

data/lib/daemonizer/engine.rb

@@ -0,0 +1,61 @@
+module Daemonizer
+  class Engine
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+    
+    def logger
+      @config.logger
+    end
+
+    def start!
+      @pm = ProcessManager.new(@config)
+
+      init_block = Proc.new do
+        @pm.start_workers do |process_id| 
+          @config.after_init.call(logger, process_id, @config.workers)
+        end
+      end
+
+      @config.before_init.call(@config.logger, init_block)
+      # Start monitoring loop
+      
+      setup_signals
+      @pm.monitor_workers
+    end
+
+=begin
+    def debug_loop!(loop_name)
+      @pm = Daemonizer::ProcessManager.new(global_config, Daemonizer.logger)
+      loop_config = loops_config[loop_name] || {}
+
+      # Adjust loop config values before starting it in debug mode
+      loop_config['workers_number'] = 1
+      loop_config['debug_loop'] = true
+
+      # Load loop class
+      unless klass = load_loop_class(loop_name, loop_config)
+        puts "Can't load loop class!"
+        return false
+      end
+
+      # Start the loop
+      start_loop(loop_name, klass, loop_config)
+    end
+=end
+    private
+      def setup_signals
+        stop = proc {
+          @config.logger.info "Received a signal... stopping..."
+          @pm.start_shutdown!
+        }
+
+        trap('TERM', stop)
+        trap('INT', stop)
+        trap('EXIT', stop)
+      end
+
+  end
+end

data/lib/daemonizer/errors.rb

@@ -0,0 +1,6 @@
+module Daemonizer::Errors
+  Error = Class.new(RuntimeError)
+
+  InvalidFrameworkError = Class.new(Error)
+  InvalidCommandError   = Class.new(Error)
+end

data/lib/daemonizer/process_manager.rb

@@ -0,0 +1,94 @@
+module Daemonizer
+  class ProcessManager
+    def initialize(config)
+      @worker_pools = {}
+      @shutdown = false
+      @config = config
+    end
+    
+    def logger
+      @config.logger
+    end
+
+    def start_workers(&blk)
+      raise ArgumentError, "Need a worker block!" unless block_given?
+
+      @worker_pools[@config.pool] = WorkerPool.new(@config.pool, self, @config.engine, &blk)
+      @worker_pools[@config.pool].start_workers(@config.workers)
+    end
+
+    def monitor_workers
+      setup_signals
+
+      logger.debug 'Starting workers monitoring code...'
+      loop do
+        logger.debug "Checking workers' health..."
+        @worker_pools.each do |name, pool|
+          break if shutdown?
+          pool.check_workers
+        end
+
+        break if shutdown?
+        logger.debug "Sleeping for #{@config.poll_period} seconds..." 
+        sleep(@config.poll_period)
+      end
+    ensure
+      logger.debug "Workers monitoring loop is finished, starting shutdown..."
+      # Send out stop signals
+      stop_workers(false)
+
+      # Wait for all the workers to die
+      unless wait_for_workers(10)
+        logger.warn "Some workers are still alive after 10 seconds of waiting. Killing them..."
+        stop_workers(true)
+        wait_for_workers(5)
+      end
+    end
+
+    def setup_signals
+      # Zombie reapers
+      trap('CHLD') {}
+      trap('EXIT') {}
+    end
+
+    def wait_for_workers(seconds)
+      seconds.times do
+        logger.debug "Shutting down... waiting for workers to die (we have #{seconds} seconds)..."
+        running_total = 0
+
+        @worker_pools.each do |name, pool|
+          running_total += pool.wait_workers
+        end
+
+        if running_total.zero?
+          logger.debug "All workers are dead. Exiting..."
+          return true
+        end
+
+        logger.debug "#{running_total} workers are still running! Sleeping for a second..."
+        sleep(1)
+      end
+
+      return false
+    end
+
+    def stop_workers(force = false)
+      # Set shutdown flag
+      logger.debug "Stopping workers#{force ? ' (forced)' : ''}..."
+
+      # Termination loop
+      @worker_pools.each do |name, pool|
+        pool.stop_workers(force)
+      end
+    end
+
+    def shutdown?
+      @shutdown
+    end
+
+    def start_shutdown!
+      logger.debug "Starting shutdown (shutdown flag set)..."
+      @shutdown = true
+    end
+  end
+end

data/lib/daemonizer/worker.rb

@@ -0,0 +1,96 @@
+module Daemonizer
+  class Worker
+    attr_reader :name
+    attr_reader :pid
+
+    def initialize(name, pm, engine, worker_id, &blk)
+      raise ArgumentError, "Need a worker block!" unless block_given?
+
+      @name = name
+      @pm = pm
+      @engine = engine.to_s
+      @worker_block = blk
+      @worker_id = worker_id
+    end
+
+    def logger
+      @pm.logger
+    end
+
+    def shutdown?
+      @pm.shutdown?
+    end
+
+    def run
+      return if shutdown?
+      if @engine == 'fork'
+        @pid = Kernel.fork do
+          @pid = Process.pid
+          GDC.set "#{@pid}/#{@worker_id}"
+          normal_exit = false
+          begin
+            $0 = "#{@name} worker: instance #{@worker_id}\0"
+            @worker_block.call(@worker_id)
+            normal_exit = true
+            exit(0)
+          rescue Exception => e
+            message = SystemExit === e ? "exit(#{e.status})" : e.to_s
+            if SystemExit === e and e.success?
+              if normal_exit
+                logger.info("Worker finished: normal return")
+              else
+                logger.error("Worker exited: #{message} at #{e.backtrace.first}")
+              end
+            else
+              logger.error("Worker exited with error: #{message}\n  #{e.backtrace.join("\n  ")}")
+            end
+            logger.debug("Terminating #{@name} worker: #{@pid}")
+          end
+        end
+      elsif @engine == 'thread'
+        @thread = Thread.start do
+          @worker_block.call
+        end
+      else
+        raise ArgumentError, "Invalid engine name: #{@engine}"
+      end
+    rescue Exception => e
+      logger.error("Exception from worker: #{e} at #{e.backtrace.first}")
+    end
+
+    def running?(verbose = false)
+      if @engine == 'fork'
+        return false unless @pid
+        begin
+          Process.waitpid(@pid, Process::WNOHANG)
+          res = Process.kill(0, @pid)
+          logger.debug("KILL(#{@pid}) = #{res}") if verbose
+          return true
+        rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM => e
+          logger.error("Exception from kill: #{e} at #{e.backtrace.first}") if verbose
+          return false
+        end
+      elsif @engine == 'thread'
+        @thread && @thread.alive?
+      else
+        raise ArgumentError, "Invalid engine name: #{@engine}"
+      end
+    end
+
+    def stop(force = false)
+      if @engine == 'fork'
+        begin
+          sig = force ? 'SIGKILL' : 'SIGTERM'
+          logger.debug("Sending #{sig} to ##{@pid}")
+          Process.kill(sig, @pid)
+        rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM=> e
+          logger.error("Exception from kill: #{e} at #{e.backtrace.first}")
+        end
+      elsif @engine == 'thread'
+        force && !defined?(::JRuby) ? @thread.kill! : @thread.kill
+      else
+        raise ArgumentError, "Invalid engine name: #{@engine}"
+      end
+    end
+  end
+end

data/lib/daemonizer/worker_pool.rb

@@ -0,0 +1,52 @@
+module Daemonizer
+  class WorkerPool
+    attr_reader :name, :logger
+
+    def initialize(name, pm, engine, &blk)
+      @name = name
+      @pm = pm
+      @worker_block = blk
+      @engine = engine
+      @workers = []
+      @logger = @pm.logger
+    end
+
+    def shutdown?
+      @pm.shutdown?
+    end
+
+    def start_workers(number)
+      logger.debug "Creating #{number} workers for #{name} pool..."
+      number.times do |i|
+        @workers << Worker.new(name, @pm, @engine, i+1, &@worker_block)
+      end
+    end
+
+    def check_workers
+      logger.debug "Checking loop #{name} workers..."
+      @workers.each do |worker|
+        next if worker.running? || worker.shutdown?
+        logger.warn "Worker #{worker.name} is not running. Restart!"
+        worker.run
+      end
+    end
+
+    def wait_workers
+      running = 0
+      @workers.each do |worker|
+        next unless worker.running?
+        running += 1
+        logger.debug "Worker #{name} is still running (#{worker.pid})"
+      end
+      return running
+    end
+
+    def stop_workers(force)
+      logger.debug "Stopping #{name} pool workers..."
+      @workers.each do |worker|
+        next unless worker.running?
+        worker.stop(force)
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: daemonizer
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Gleb Pomykalov
@@ -15,14 +15,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 +04:00
-default_executable: 
-dependencies: []
-
-description: Inspired by bundler. Mostly build on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops
+date: 2010-07-06 00:00:00 +04:00
+default_executable: daemonizer
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 1
+        - 8
+        version: 1.1.8
+  type: :runtime
+  version_requirements: *id001
+description: Inspired by bundler and rack. Mostly built on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops
 email: glebpom@gmail.com
-executables: []
-
+executables: 
+- daemonizer
 extensions: []
 
 extra_rdoc_files: 
@@ -31,6 +46,19 @@ files:
 - README
 - Rakefile
 - VERSION
+- bin/daemonizer
+- daemonizer.gemspec
+- lib/daemonizer.rb
+- lib/daemonizer/autoload.rb
+- lib/daemonizer/cli.rb
+- lib/daemonizer/config.rb
+- lib/daemonizer/daemonize.rb
+- lib/daemonizer/dsl.rb
+- lib/daemonizer/engine.rb
+- lib/daemonizer/errors.rb
+- lib/daemonizer/process_manager.rb
+- lib/daemonizer/worker.rb
+- lib/daemonizer/worker_pool.rb
 has_rdoc: true
 homepage: http://github.com/glebpom/daemonizer
 licenses: []