daemonizer 0.1.6 → 0.2.0

data/README.md

@@ -43,7 +43,6 @@ Usage
 
 **Demfile example:**
 
-    engine :fork 
     workers 2
 
     pool :daemonizer do
@@ -51,11 +50,11 @@ Usage
       poll_period 5
       log_file "log/daemonizer.log" #relative to Demfile
   
-      before_init do |logger, block|
+      prepare do |logger, block|
         block.call
       end
   
-      after_init do |logger, worker_id, workers_count|
+      start do |logger, worker_id, workers_count|
         logger.info "Started #{worker_id} from #{workers_count}"
     
         exit = false
@@ -97,6 +96,11 @@ Usage
       
       #lambda-option (transparent for daemonizer, fully processed by handler)
       set_option :on_error, lambda { |object| object.logger.fatal "epic fail"}
+      
+      #executes after worker forked but before start block invoked
+      after_fork do |logger, worker_id, workers_count|
+        #reconnect to db, etc.
+      end
     end
 
 
@@ -126,7 +130,7 @@ Who are the authors
 
 This gem has been created in qik.com for our internal use and then 
 the sources were opened for other people to use. All the code in this package 
-has been developed by Gleb Pomykalov, and is based on 
-[http://github.com/kovyrin/loops](loops) code written by 
-Alexey Kovyrin. The gem is released under the MIT license. For more details, 
-see the LICENSE file.
+has been developed by Gleb Pomykalov. As for the first versions, it was mostly based
+ on [http://github.com/kovyrin/loops](loops) code written by Alexey Kovyrin. Now
+most of it is heavily refactored.  The gem is released under the MIT license. For
+more details, see the LICENSE file.

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.0

data/daemonizer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{daemonizer}
-  s.version = "0.1.6"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gleb Pomykalov"]
-  s.date = %q{2010-07-13}
+  s.date = %q{2010-07-14}
   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}

data/lib/daemonizer.rb

@@ -32,6 +32,25 @@ module Daemonizer
       "Demfile"
     end
   end
+  
+  def self.init_logger(name, log_file)
+    @@logger = Logger.new name
+    outputter = FileOutputter.new('log', :filename => log_file)
+    outputter.formatter = PatternFormatter.new :pattern => "%d - %l %g - %m"
+    @@logger.outputters = outputter
+    @@logger.level = INFO
+  end
+  
+  def self.init_console_logger(name)
+    @@logger = Logger.new name
+    outputter = Outputter.stdout
+    outputter.formatter = PatternFormatter.new :pattern => "%d - %l %g - %m"
+    @@logger.outputters = outputter
+  end
+  
+  def self.logger
+    @@logger
+  end
 
   def self.[](pool)
     find_pools(pool).first or nil

data/lib/daemonizer/cli.rb

@@ -87,7 +87,7 @@ module Daemonizer
     desc "debug", "Debug pool (do not demonize)"
     def debug(pool_name = nil)
       puts "You should supply pool_name to debug" if pool_name.nil?
-      control_pools_loop(pool_name, "execution ended") do |pool|
+      control_pools_loop(pool_name, "execution ended", true) do |pool|
         STDOUT.sync = true
         print_pool pool.name,  "Debugging pool: "
         
@@ -101,9 +101,14 @@ module Daemonizer
     end
     
   private
-    def control_pools_loop(pool_name, message = nil, &block)
+    def control_pools_loop(pool_name, message = nil, debug = false, &block)
       Daemonizer.find_pools(pool_name).each do |pool|
         Process.fork do
+          if debug
+            Daemonizer.init_console_logger(pool.name.to_s)
+          else
+            Daemonizer.init_logger(pool.name.to_s, pool.log_file)
+          end
           yield(pool)
         end
         Process.wait

data/lib/daemonizer/config.rb

@@ -11,28 +11,19 @@ module Daemonizer
       validate
       initialize_handler
     end
-    
-    def option(key)
-      if handler
-        handler.option(key) 
-      else
-        raise ConfigError, "handler is not initialized"
-      end
-    end
 
     def initialize_handler
-      if @options[:after_init]
-        @handler = FakeHandler.new(@options[:before_init], @options[:after_init], @options)
-        @options[:after_init] = @options[:before_init] = nil
+      if @options[:start]
+        @handler = FakeHandler.new(@options[:prepare], @options[:start], @options)
+        @options[:start] = @options[:prepare] = nil
       elsif
         @handler = @options[:handler].new(@options[:handler_options])
       end
-      @handler.logger = @logger
     end
 
     def init_defaults
-      @options[:before_init] ||= nil
-      @options[:after_init] ||= nil
+      @options[:prepare] ||= nil
+      @options[:start] ||= nil
       @options[:workers] ||= 1
       @options[:log_file] ||= "log/#{@pool}.log"
       @options[:poll_period] ||= 5
@@ -47,14 +38,14 @@ module Daemonizer
       raise ConfigError, "Poll period should be more then zero" if @options[:poll_period] < 1
       if @options[:handler]
         raise ConfigError, "Handler should be a class" unless @options[:handler].is_a?(Class)
-        raise ConfigError, "Handler should respond to :after_init" unless @options[:handler].public_instance_methods.include?('after_init')
-        raise ConfigError, "Handler set. Don't use :after_init and :before init in Demfile" if @options[:before_init] || @options[:after_init]
+        raise ConfigError, "Handler should respond to :start" unless @options[:handler].public_instance_methods.include?('start')
+        raise ConfigError, "Handler set. Don't use :start and :before init in Demfile" if @options[:prepare] || @options[:start]
       else
-        if @options[:before_init]
-          raise ConfigError, "before_init should have block" unless @options[:before_init].is_a?(Proc)
+        if @options[:prepare]
+          raise ConfigError, "prepare should have block" unless @options[:prepare].is_a?(Proc)
         end
-        raise ConfigError, "after_init should be set" if @options[:after_init].nil?
-        raise ConfigError, "after_init should have block" unless @options[:after_init].is_a?(Proc)
+        raise ConfigError, "start should be set" if @options[:start].nil?
+        raise ConfigError, "start should have block" unless @options[:start].is_a?(Proc)
       end
     end
 

data/lib/daemonizer/dsl.rb

@@ -24,6 +24,10 @@ class Daemonizer::Dsl
       raise DslError, "you should supply block or value to :set_option"
     end
   end
+  
+  def after_fork(&block)
+    set_option :after_fork, block
+  end
 
   def not_cow_friendly
     @options[:cow_friendly] = false
@@ -45,12 +49,12 @@ class Daemonizer::Dsl
     @options[:workers] = num.to_i
   end
     
-  def before_init(&blk)
-    @options[:before_init] = blk
+  def prepare(&blk)
+    @options[:prepare] = blk
   end
   
-  def after_init(&blk)
-    @options[:after_init] = blk
+  def start(&blk)
+    @options[:start] = blk
   end
   
   def pid_file(pid)

data/lib/daemonizer/engine.rb

@@ -1,27 +1,22 @@
 module Daemonizer
   class Engine
     attr_reader :config
-    attr_reader :logger
 
     def initialize(config, debug = false)
       @config = config
-      @logger = Logger.new @config.name.to_s
-      outputter = FileOutputter.new('log', :filename => @config.log_file)
-      outputter.formatter = PatternFormatter.new :pattern => "%d - %l %g - %m"
-      @logger.outputters = outputter
-      @logger.level = INFO
       GDC.set "#{Process.pid}/monitor"
     end
-
+    
     def start!
       @pm = ProcessManager.new(@config)
 
       init_block = Proc.new do
         begin
-          @pm.start_workers do |process_id| 
+          @pm.start_workers do |process_id|
             @config.handler.worker_id = process_id
             @config.handler.workers_count = @config.workers
-            @config.handler.after_init
+            @config.handler.after_fork
+            @config.handler.start
           end
         rescue Exception => e
           log_error(e)
@@ -32,13 +27,14 @@ module Daemonizer
         if @config.cow_friendly
           if GC.respond_to?(:copy_on_write_friendly=)
           	GC.copy_on_write_friendly = true
-          	logger.info "Enabling COW-friendly feature"
+          	Daemonizer.logger.info "Enabling COW-friendly feature"
           else
-          	logger.info "COW-friendly feature is not supported by currently used ruby version"
+          	Daemonizer.logger.info "COW-friendly feature is not supported by currently used ruby version"
           end
         end
-        @config.handler.logger = logger        
-        @config.handler.before_init(init_block)
+        Daemonizer.logger.info "Workers count is #{config.workers}"
+        @config.handler.logger = Daemonizer.logger
+        @config.handler.prepare(init_block)
       rescue Exception => e
         log_error(e)
       end
@@ -49,37 +45,34 @@ module Daemonizer
     end
 
     def debug!
-      outputter = Outputter.stdout
-      outputter.formatter = PatternFormatter.new :pattern => "%d - %l %g - %m"
-      logger.outputters = outputter
-
+      Daemonizer.init_console_logger
+      
       init_block = Proc.new do
         begin
           @config.handler.worker_id = 1
           @config.handler.workers_count = 1
-          @config.handler.after_init
+          @config.handler.start
         rescue Exception => e
           log_error(e)
         end
       end
 
       begin
-        @config.handler.logger = logger        
-        @config.handler.before_init(init_block)
+        @config.handler.prepare(init_block)
       rescue Exception => e
         log_error(e)
       end
     end
     
     def log_error(e)
-      logger.fatal e.to_s
-      logger.fatal "#{e.class}: #{e}\n" + e.backtrace.join("\n")
+      Daemonizer.logger.fatal e.to_s
+      Daemonizer.logger.fatal "#{e.class}: #{e}\n" + e.backtrace.join("\n")
     end
 
     private
       def setup_signals
         stop = proc {
-          @config.logger.info "Received a signal... stopping..."
+          Daemonizer.logger.info "Received a signal... stopping..."
           @pm.start_shutdown!
         }
 

data/lib/daemonizer/handler.rb

@@ -4,40 +4,46 @@ module Daemonizer
     attr_accessor :workers_count
     attr_accessor :logger
     
-    def initialize(options = {})
-      @options = options
+    def initialize(handler_options = {})
+      @handler_options = handler_options
     end
     
-    def before_init(block)
+    def prepare(block)
       block.call
     end
     
     def option(key)
-      if option = @options[key.to_sym]
-        option.value(self)
+      if handler_option = @handler_options[key.to_sym]
+        handler_option.value(self)
       else
         nil
       end
     end
+    
+    def after_fork
+      if block = option(:after_fork)
+        block.call(Daemonizer.logger, @worker_id, @workers_count)
+      end
+    end
   end
   
   class FakeHandler < Handler
-    def initialize(before_init, after_init, options = {})
-      @before_init = before_init
-      @after_init = after_init
-      super(options)
+    def initialize(prepare, start, handler_options = {})
+      @prepare = prepare
+      @start = start
+      super(handler_options)
     end
     
-    def before_init(block)
-      if @before_init
-        @before_init.call(@logger, block)
+    def prepare(block)
+      if @prepare
+        @prepare.call(Daemonizer.logger, block)
       else
         super
       end
     end
         
-    def after_init
-      @after_init.call(@logger, @worker_id, @workers_count)
+    def start
+      @start.call(Daemonizer.logger, @worker_id, @workers_count)
     end
   end
 end

data/lib/daemonizer/process_manager.rb

@@ -5,14 +5,11 @@ module Daemonizer
       @shutdown = false
       @config = config
     end
-    
-    def logger
-      @config.logger
-    end
+
 
     def start_workers(&blk)
       raise ArgumentError, "Need a worker block!" unless block_given?
-
+      Daemonizer.logger.info "starting all workers"
       @worker_pools[@config.pool] = WorkerPool.new(@config.pool, self, &blk)
       @worker_pools[@config.pool].start_workers(@config.workers)
     end
@@ -20,26 +17,26 @@ module Daemonizer
     def monitor_workers
       setup_signals
 
-      logger.debug 'Starting workers monitoring code...'
+      Daemonizer.logger.debug 'Starting workers monitoring code...'
       loop do
-        logger.debug "Checking workers' health..."
+        Daemonizer.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..." 
+        Daemonizer.logger.debug "Sleeping for #{@config.poll_period} seconds..." 
         sleep(@config.poll_period)
       end
     ensure
-      logger.debug "Workers monitoring loop is finished, starting shutdown..."
+      Daemonizer.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..."
+        Daemonizer.logger.warn "Some workers are still alive after 10 seconds of waiting. Killing them..."
         stop_workers(true)
         wait_for_workers(5)
       end
@@ -53,7 +50,7 @@ module Daemonizer
 
     def wait_for_workers(seconds)
       seconds.times do
-        logger.debug "Shutting down... waiting for workers to die (we have #{seconds} seconds)..."
+        Daemonizer.logger.debug "Shutting down... waiting for workers to die (we have #{seconds} seconds)..."
         running_total = 0
 
         @worker_pools.each do |name, pool|
@@ -61,11 +58,11 @@ module Daemonizer
         end
 
         if running_total.zero?
-          logger.debug "All workers are dead. Exiting..."
+          Daemonizer.logger.debug "All workers are dead. Exiting..."
           return true
         end
 
-        logger.debug "#{running_total} workers are still running! Sleeping for a second..."
+        Daemonizer.logger.debug "#{running_total} workers are still running! Sleeping for a second..."
         sleep(1)
       end
 
@@ -74,7 +71,7 @@ module Daemonizer
 
     def stop_workers(force = false)
       # Set shutdown flag
-      logger.debug "Stopping workers#{force ? ' (forced)' : ''}..."
+      Daemonizer.logger.debug "Stopping workers#{force ? ' (forced)' : ''}..."
 
       # Termination loop
       @worker_pools.each do |name, pool|
@@ -87,7 +84,7 @@ module Daemonizer
     end
 
     def start_shutdown!
-      logger.debug "Starting shutdown (shutdown flag set)..."
+      Daemonizer.logger.debug "Starting shutdown (shutdown flag set)..."
       @shutdown = true
     end
   end

data/lib/daemonizer/worker.rb

@@ -8,21 +8,17 @@ module Daemonizer
 
       @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?
+      Daemonizer.logger.info "Forking..."
       @pid = Kernel.fork do
         Dir.chdir '/'
         File.umask 0000
@@ -32,7 +28,9 @@ module Daemonizer
         STDERR.reopen STDOUT
         
         @pid = Process.pid
+        
         GDC.set "#{@pid}/#{@worker_id}"
+        Daemonizer.logger.info "Forked..."
         normal_exit = false
         begin
           $0 = "#{@name} worker: instance #{@worker_id}\0"
@@ -43,18 +41,18 @@ module Daemonizer
           message = SystemExit === e ? "exit(#{e.status})" : e.to_s
           if SystemExit === e and e.success?
             if normal_exit
-              logger.info("Worker finished: normal return")
+              Daemonizer.logger.info("Worker finished: normal return")
             else
-              logger.error("Worker exited: #{message} at #{e.backtrace.first}")
+              Daemonizer.logger.error("Worker exited: #{message} at #{e.backtrace.first}")
             end
           else
-            logger.error("Worker exited with error: #{message}\n  #{e.backtrace.join("\n  ")}")
+            Daemonizer.logger.error("Worker exited with error: #{message}\n  #{e.backtrace.join("\n  ")}")
           end
-          logger.debug("Terminating #{@name} worker: #{@pid}")
+          Daemonizer.logger.debug("Terminating #{@name} worker: #{@pid}")
         end
       end
     rescue Exception => e
-      logger.error("Exception from worker: #{e} at #{e.backtrace.first}")
+      Daemonizer.logger.error("Exception from worker: #{e} at #{e.backtrace.first}")
     end
 
     def running?(verbose = false)
@@ -62,10 +60,10 @@ module Daemonizer
       begin
         Process.waitpid(@pid, Process::WNOHANG)
         res = Process.kill(0, @pid)
-        logger.debug("KILL(#{@pid}) = #{res}") if verbose
+        Daemonizer.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
+        Daemonizer.logger.error("Exception from kill: #{e} at #{e.backtrace.first}") if verbose
         return false
       end
     end
@@ -73,10 +71,10 @@ module Daemonizer
     def stop(force = false)
       begin
         sig = force ? 'SIGKILL' : 'SIGTERM'
-        logger.debug("Sending #{sig} to ##{@pid}")
+        Daemonizer.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}")
+        Daemonizer.logger.error("Exception from kill: #{e} at #{e.backtrace.first}")
       end
     end
   end

data/lib/daemonizer/worker_pool.rb

@@ -1,13 +1,12 @@
 module Daemonizer
   class WorkerPool
-    attr_reader :name, :logger
+    attr_reader :name
 
     def initialize(name, pm, &blk)
       @name = name
       @pm = pm
       @worker_block = blk
       @workers = []
-      @logger = @pm.logger
     end
 
     def shutdown?
@@ -15,17 +14,17 @@ module Daemonizer
     end
 
     def start_workers(number)
-      logger.debug "Creating #{number} workers for #{name} pool..."
+      Daemonizer.logger.debug "Creating #{number} workers for #{name} pool..."
       number.times do |i|
         @workers << Worker.new(name, @pm, i+1, &@worker_block)
       end
     end
 
     def check_workers
-      logger.debug "Checking loop #{name} workers..."
+      Daemonizer.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!"
+        Daemonizer.logger.warn "Worker #{worker.name} is not running. Restart!"
         worker.run
       end
     end
@@ -35,13 +34,13 @@ module Daemonizer
       @workers.each do |worker|
         next unless worker.running?
         running += 1
-        logger.debug "Worker #{name} is still running (#{worker.pid})"
+        Daemonizer.logger.debug "Worker #{name} is still running (#{worker.pid})"
       end
       return running
     end
 
     def stop_workers(force)
-      logger.debug "Stopping #{name} pool workers..."
+      Daemonizer.logger.debug "Stopping #{name} pool workers..."
       @workers.each do |worker|
         next unless worker.running?
         worker.stop(force)

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 6
-  version: 0.1.6
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Gleb Pomykalov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-13 00:00:00 +04:00
+date: 2010-07-14 00:00:00 +04:00
 default_executable: daemonizer
 dependencies: 
 - !ruby/object:Gem::Dependency