daemonizer 0.4.18 → 0.5.0.beta.1

data/spec/settings/callbacks_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+class CallbacksSpecHandler < SpecHandler
+  class <<self
+    attr_accessor :call_on_prepare
+    attr_accessor :call_on_start
+  end
+
+  def start
+    self.class.call_on_start && self.class.call_on_start.call
+    super
+  end
+
+  def prepare(starter, &block)
+    self.class.call_on_prepare && self.class.call_on_prepare.call
+    super
+  end
+end
+
+
+describe "callbacks in Daemonfile" do
+  before :each do
+    stubs_logger
+  end
+
+  %w(after_prepare before_prepare before_start).each do |callback|
+    context "initializing #{callback} callbacks" do
+      before :each do
+        @eval = Daemonizer::Dsl.evaluate(<<-G)
+          #{callback} do
+            1
+          end
+
+          pool :test do
+            #{callback} do
+              2
+            end
+
+            #{callback} do
+              3
+            end
+          end
+        G
+      end
+
+      it { @eval.configs[:test][:callbacks].should be_kind_of(Hash) }
+      it { @eval.configs[:test][:callbacks][callback.to_sym].should be_kind_of(Array) }
+      it { @eval.configs[:test][:callbacks][callback.to_sym].size.should == 3 }
+      it "should keep valid callbacks order" do
+        @eval.configs[:test][:callbacks][callback.to_sym][0].call.should == 1
+        @eval.configs[:test][:callbacks][callback.to_sym][1].call.should == 2
+        @eval.configs[:test][:callbacks][callback.to_sym][2].call.should == 3
+      end
+    end
+  end
+end
+
+describe "callbacks in Daemonizer::Config" do
+  before :each do
+    stubs_logger
+  end
+
+  before :each do
+    CallbacksSpecHandler.call_on_prepare = lambda { @engine_state.become('prepare_invoked') }
+    CallbacksSpecHandler.call_on_start = lambda { @engine_state.become('start_invoked') }
+
+    @engine_state = states('engine_state').starts_as('pending')
+  end
+
+  it "should work in correct order with many callbacks" do
+    @before_prepare = mock('before_prepare')
+    @before_prepare.expects('touch').when(@engine_state.is('pending')).twice
+
+    @after_prepare = mock('after_prepare')
+    @after_prepare.expects('touch').when(@engine_state.is('prepare_invoked')).twice
+
+    @before_start = mock('before_start')
+    @before_start.expects('touch').when(@engine_state.is('after_prepare_invoked')).twice
+
+    @callbacks = {
+      :before_prepare => [ Proc.new { @before_prepare.touch }, Proc.new { @before_prepare.touch; @engine_state.become('before_prepare_invoked') } ],
+      :after_prepare =>  [ Proc.new { @after_prepare.touch }, Proc.new { @after_prepare.touch; @engine_state.become('after_prepare_invoked') }  ],
+      :before_start =>   [ Proc.new { @before_start.touch }, Proc.new { @before_start.touch; @engine_state.become('before_start_invoked') } ]
+    }
+
+    @engine = Daemonizer::Engine.new(Daemonizer::Config.new(:pool, {
+              :workers => 1,
+              :pid_file =>"#{tmp_dir}/test1.pid",
+              :log_file =>"#{tmp_dir}/test1.log",
+              :callbacks => @callbacks,
+              :handler => CallbacksSpecHandler
+    }))
+    @engine.run_prepare_with_callbacks do
+      @engine.run_start_with_callbacks
+    end
+  end
+
+  after :each do
+    CallbacksSpecHandler.call_on_prepare = nil
+    CallbacksSpecHandler.call_on_start = nil
+  end
+
+end

data/spec/settings/options_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+class OptionsSpecHandler < SpecHandler; end
+
+describe "set_option in Daemonfile" do
+  it "should initialize simple setting correctly" do
+    Daemonizer::Option.expects(:new).with(:simple, "simple_value").once
+    Daemonizer::Dsl.evaluate(<<-G)
+      pool :test do
+        set_option :simple, "simple_value"
+      end
+    G
+  end
+
+  it "should initialize block setting correctly" do
+    Daemonizer::Option.expects(:new).with(:lambda, kind_of(Proc), any_of(true, nil)).once
+    Daemonizer::Dsl.evaluate(<<-G)
+      pool :test do
+        set_option :lambda do
+          "lambda_value"
+        end
+      end
+    G
+  end
+
+  it "should correctly set option_handlers" do
+    @eval = Daemonizer::Dsl.evaluate(<<-G)
+      pool :test do
+        set_option :option1, "option1_value"
+        set_option :option2, "option1_value"
+        set_option :option3, "option1_value"
+      end
+    G
+    @eval.configs[:test][:handler_options].should be_kind_of(Hash)
+    @eval.configs[:test][:handler_options].size.should == 3
+  end
+
+  it "should raise DslError if nothing provided to set_option" do
+    lambda {
+      Daemonizer::Dsl.evaluate(<<-G)
+        pool :test do
+          set_option :option1, nil
+        end
+      G
+    }.should raise_error Daemonizer::Dsl::DslError
+  end
+end
+
+describe "pool options in Daemonizer::Config" do
+  context "with name and value" do
+    before :each do
+      @handler = Daemonizer::Engine.new(Daemonizer::Config.new(:pool, {
+                :workers => 1,
+                :pid_file =>"#{tmp_dir}/test1.pid",
+                :log_file =>"#{tmp_dir}/test1.log",
+                :handler_options => {
+                    :simple => Daemonizer::Option.new(:simple, "simple_value"),
+                    :lambda => Daemonizer::Option.new(:lambda, lambda { "lambda_value" }),
+                    :block => Daemonizer::Option.new(:block, lambda { "block_value" }, true)
+                 },
+                :handler => OptionsSpecHandler
+      })).run_start_with_callbacks
+    end
+
+    it "should return simple option" do
+      @handler.option(:simple).should == "simple_value"
+    end
+
+    it "should return lambda value" do
+      @handler.option(:lambda).should be_kind_of(Proc)
+    end
+
+    it "should return simple option" do
+      @handler.option(:block).should == "block_value"
+    end
+
+  end
+
+end
+
+describe Daemonizer::Option do
+  context "with auto_eval set to true" do
+    context "and not lambda value" do
+      it do
+        lambda {
+          Daemonizer::Option.new(:option, "not_lambda", true)
+        }.should raise_error(Daemonizer::Option::OptionError)
+      end
+    end
+
+    context "and lambda value" do
+      context "and handler is not defined" do
+        it do
+          lambda {
+            Daemonizer::Option.new(:option, lambda { "lambda" }, true).value
+          }.should raise_error(Daemonizer::Option::OptionError)
+        end
+      end
+      context "and handler defined" do
+        context "with arity == 0" do
+          it do
+            Daemonizer::Option.new(:option, lambda { "lambda" }, true).
+              value(OptionsSpecHandler.new).
+              should == "lambda"
+          end
+        end
+
+        context "with arity == 2" do
+          it do
+            Daemonizer::Option.new(:option, lambda { |worker_id, workers_count| "#{worker_id}/#{workers_count}" }, true).
+              value(OptionsSpecHandler.new).
+              should == "1/1"
+          end
+        end
+
+        context "with arity == 1" do
+
+          it do
+            lambda {
+              Daemonizer::Option.new(:option, lambda { |worker_id| "lambda" }, true).
+              value(OptionsSpecHandler.new)
+            }.should raise_error(Daemonizer::Option::OptionError)
+          end
+
+        end
+
+      end
+    end
+  end
+
+  context "with auto_eval set to false" do
+    context "and not lambda value" do
+      it do
+        Daemonizer::Option.new(:option, "simple").value.should == "simple"
+      end
+    end
+
+    context "and lambda value" do
+      it do
+        Daemonizer::Option.new(:option, lambda { "lambda" }).value.
+          should be_kind_of(Proc)
+      end
+    end
+  end
+
+end

data/spec/settings/pools_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe "Evaluating pool settings through dsl" do
+  before :each do
+    @dsl = Daemonizer::Dsl.evaluate(<<-EOF)
+      poll_period 10
+
+      pool "pool1" do
+        workers 1
+
+        not_cow_friendly
+      end
+      pool "pool2" do
+        workers 2
+        poll_period 2
+      end
+    EOF
+
+    @configuration = @dsl.configs
+  end
+
+  it "should create 2 pool record" do
+    @configuration.size.should == 2
+  end
+
+  it "should set parameters on pools isolated" do
+    @configuration[:pool1].keys.should include(:workers, :poll_period, :cow_friendly)
+    @configuration[:pool2].keys.should include(:workers, :poll_period)
+    @configuration[:pool2].keys.should_not include(:cow_friendly)
+  end
+
+  it "should correctly inherit parameters from top level" do
+    @configuration[:pool1][:poll_period].should == 10
+    @configuration[:pool2][:poll_period].should == 2
+  end
+
+  it "should process pool definition on call Daemonizer::Dsl#process" do
+    pool_config = Daemonizer::Config
+    pool_config.expects(:new).with(:pool2, equals(@configuration[:pool2])).once
+    pool_config.expects(:new).with(:pool1, equals(@configuration[:pool1])).once
+    @processed_config = @dsl.process
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,57 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'test'
-require 'spec'
-require 'spec/autorun'
-
-Spec::Runner.configure do |config|
-  
+#$:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'daemonizer'
+require 'fileutils'
+require 'rubygems'
+require 'rspec'
+require 'open3'
+
+Dir["#{File.expand_path('support', File.dirname(__FILE__))}/*.rb"].each do |file|
+  require file
+end
+
+$debug    = false
+$show_err = true
+
+FileUtils.rm_rf(Spec::Path.app_root)
+
+RSpec.configure do |config|
+  config.include Spec::Helpers
+  config.include Spec::Path
+  config.include Spec::DaemonfileFactory
+  config.include Spec::Processes
+
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+  config.alias_example_to :fit, :focused => true
+
+  config.mock_with :mocha
+
+  original_wd = Dir.pwd
+
+  config.before :each do
+    reset!
+    in_app_root
+  end
+
+  config.after :each do
+    Dir.chdir(original_wd)
+  end
+end
+
+class SpecHandler < Daemonizer::Handler
+  def initialize(*args)
+    @worker_id = 1
+    @workers_count = 1
+    super
+  end
+
+  def prepare(starter, &block)
+    super
+  end
+
+  def start
+    self
+  end
 end

data/spec/support/daemonfile_factory.rb

@@ -0,0 +1,33 @@
+module Spec
+  module DaemonfileFactory
+    def simple_daemonfile(*pools)
+      code = ""
+      pid_files = pools.map do |pool|
+        if pool[:exit_on_start]
+        end
+        code << <<EOF
+pool :#{pool[:name]} do
+  workers #{pool[:workers] || 1}
+  poll_period #{pool[:poll_period] || 1}
+  log_file "test.log"
+  pid_file "#{pool[:pid_file]}"
+
+  prepare do |block|
+    #{pool[:on_prepare]}
+    block.call
+  end
+
+  start do |worker_id, workers_count|
+    trap("TERM") { exit 0; }
+     #{pool[:on_start]}
+  end
+end
+
+EOF
+        pool[:pid_file]
+      end
+      daemonfile code
+      pid_files
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,70 @@
+module Spec
+  module Helpers
+    def reset!
+      kill_if_running!
+      FileUtils.rm_rf(app_root)
+      FileUtils.mkdir_p(app_root)
+    end
+
+    def in_app_root(&blk)
+      Dir.chdir(app_root, &blk)
+    end
+
+    def daemonizer(cmd)
+      sys_exec File.join(gem_root, 'bin/daemonizer') + " " + cmd.to_s
+    end
+
+    def daemonfile(code)
+      File.open(File.join(app_root, "Daemonfile"), 'w') do |f|
+        f.puts code
+      end
+    end
+
+    attr_reader :out, :err, :exitstatus
+
+    def sys_exec(cmd, expect_err = false)
+      Open3.popen3(cmd.to_s) do |stdin, stdout, stderr|
+        @in_p, @out_p, @err_p = stdin, stdout, stderr
+
+        yield @in_p if block_given?
+        @in_p.close
+
+        @out = @out_p.read_available_bytes.strip
+        @err = @err_p.read_available_bytes.strip
+      end
+
+      puts @err unless expect_err || @err.empty? || !$show_err
+      @out
+    end
+
+    def kill_if_running!
+      Dir["#{tmp_dir}/**/*.pid"].each do |pid_file|
+        pid = File.read(pid_file).chomp
+        if pid.to_i > 0
+          puts "Warning: Daemonizer was not properly stopped. Stop it in after block. Killing #{pid.to_i}"
+          Process.kill("TERM", pid.to_i) rescue true
+          sleep 5
+        end
+      end
+    end
+
+    def daemonizer_runned?(pid_file)
+      pid = File.read(pid_file).chomp.to_i
+      if pid.to_i > 0
+        return !!Process.kill(0, pid.to_i)
+      else
+        return false
+      end
+    rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM
+      false
+    end
+
+    def stubs_logger
+      logger = stubs(:logger)
+      logger.stubs(:info).returns(true)
+      Daemonizer.stubs(:logger).returns(logger)
+    end
+
+    extend self
+  end
+end