serverengine 2.0.0pre1-x86-mingw32

data/spec/daemon_spec.rb

@@ -0,0 +1,169 @@
+
+describe ServerEngine::Daemon do
+  include_context 'test server and worker'
+
+  it 'run and graceful stop by signal' do
+    pending "not supported signal base commands on Windows" if ServerEngine.windows?
+
+    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid", command_sender: "signal")
+    dm.main
+
+    wait_for_fork
+
+    test_state(:server_initialize).should == 1
+
+    begin
+      dm.stop(true)
+      wait_for_stop
+
+      test_state(:server_stop_graceful).should == 1
+      test_state(:worker_stop).should == 1
+      test_state(:server_after_run).should == 1
+    ensure
+      dm.stop(false) rescue nil
+    end
+  end
+
+  it 'signals' do
+    pending "not supported signal base commands on Windows" if ServerEngine.windows?
+    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid", command_sender: "signal")
+    dm.main
+
+    wait_for_fork
+
+    begin
+      dm.reload
+      wait_for_stop
+      test_state(:server_reload).should == 1
+
+      dm.restart(true)
+      wait_for_stop
+      test_state(:server_restart_graceful).should == 1
+
+      dm.restart(false)
+      wait_for_stop
+      test_state(:server_restart_immediate).should == 1
+
+      dm.stop(false)
+      wait_for_stop
+      test_state(:server_stop_immediate).should == 1
+    ensure
+      dm.stop(true) rescue nil
+    end
+  end
+
+  it 'run and graceful stop by pipe' do
+    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid", windows_daemon_cmdline: windows_daemon_cmdline, command_sender: "pipe")
+    dm.main
+
+    wait_for_fork
+
+    test_state(:server_initialize).should == 1
+
+    begin
+      dm.stop(true)
+      wait_for_stop
+
+      test_state(:server_stop_graceful).should == 1
+      test_state(:worker_stop).should == 1
+      test_state(:server_after_run).should == 1
+    ensure
+      dm.stop(false) rescue nil
+    end
+  end
+
+  it 'recieve commands from pipe' do
+    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid", windows_daemon_cmdline: windows_daemon_cmdline, command_sender: "pipe")
+    dm.main
+
+    wait_for_fork
+
+    begin
+      dm.reload
+      wait_for_stop
+      test_state(:server_reload).should == 1
+
+      dm.restart(true)
+      wait_for_stop
+      test_state(:server_restart_graceful).should == 1
+
+      dm.restart(false)
+      wait_for_stop
+      test_state(:server_restart_immediate).should == 1
+
+      dm.stop(false)
+      wait_for_stop
+      test_state(:server_stop_immediate).should == 1
+    ensure
+      dm.stop(true) rescue nil
+    end
+  end
+
+  it 'exits with status 0 when it was stopped normally' do
+    pending "worker type process(fork) cannot be used in Windows" if ServerEngine.windows?
+    dm = Daemon.new(
+      TestServer,
+      TestWorker,
+      daemonize: false,
+      supervisor: false,
+      pid_path: "tmp/pid",
+      log_stdout: false,
+      log_stderr: false,
+      unrecoverable_exit_codes: [3,4,5],
+    )
+    exit_code = nil
+    t = Thread.new { exit_code = dm.main }
+    sleep 0.1 until dm.instance_eval{ @pid }
+    dm.stop(true)
+
+    t.join
+
+    exit_code.should == 0
+  end
+
+  it 'exits with status of workers if worker exits with status specified in unrecoverable_exit_codes, without supervisor' do
+    pending "worker type process(fork) cannot be used in Windows" if ServerEngine.windows?
+
+    dm = Daemon.new(
+      TestServer,
+      TestExitWorker,
+      daemonize: false,
+      supervisor: false,
+      worker_type: 'process',
+      pid_path: "tmp/pid",
+      log_stdout: false,
+      log_stderr: false,
+      unrecoverable_exit_codes: [3,4,5],
+    )
+    exit_code = nil
+    t = Thread.new { exit_code = dm.main }
+    sleep 0.1 until dm.instance_eval{ @pid }
+
+    t.join
+
+    exit_code.should == 5
+  end
+
+  it 'exits with status of workers if worker exits with status specified in unrecoverable_exit_codes, with supervisor' do
+    pending "worker type process(fork) cannot be used in Windows" if ServerEngine.windows?
+
+    dm = Daemon.new(
+      TestServer,
+      TestExitWorker,
+      daemonize: false,
+      supervisor: true,
+      worker_type: 'process',
+      pid_path: "tmp/pid",
+      log_stdout: false,
+      log_stderr: false,
+      unrecoverable_exit_codes: [3,4,5],
+    )
+    exit_code = nil
+    t = Thread.new { exit_code = dm.main }
+    sleep 0.1 until dm.instance_eval{ @pid }
+
+    t.join
+
+    exit_code.should == 5
+  end
+end

data/spec/multi_process_server_spec.rb

@@ -0,0 +1,113 @@
+[ServerEngine::MultiThreadServer, ServerEngine::MultiProcessServer].each do |impl_class|
+  # MultiProcessServer uses fork(2) internally, then it doesn't support Windows.
+
+  describe impl_class do
+    include_context 'test server and worker'
+
+    it 'scale up' do
+      pending "Windows environment does not support fork" if ServerEngine.windows? && impl_class == ServerEngine::MultiProcessServer
+
+      config = {workers: 2, log_stdout: false, log_stderr: false}
+
+      s = impl_class.new(TestWorker) { config.dup }
+      t = Thread.new { s.main }
+
+      begin
+        wait_for_fork
+        test_state(:worker_run).should == 2
+
+        config[:workers] = 3
+        s.reload
+
+        wait_for_restart
+        test_state(:worker_run).should == 3
+
+        test_state(:worker_stop).should == 0
+
+      ensure
+        s.stop(true)
+        t.join
+      end
+
+      test_state(:worker_stop).should == 3
+    end
+
+    it 'scale down' do
+      pending "Windows environment does not support fork" if ServerEngine.windows? && impl_class == ServerEngine::MultiProcessServer
+
+      config = {workers: 2, log_stdout: false, log_stderr: false}
+
+      s = impl_class.new(TestWorker) { config.dup }
+      t = Thread.new { s.main }
+
+      begin
+        wait_for_fork
+        test_state(:worker_run).should == 2
+
+        config[:workers] = 1
+        s.restart(true)
+
+        wait_for_restart
+        test_state(:worker_run).should == 3
+
+        test_state(:worker_stop).should == 2
+
+      ensure
+        s.stop(true)
+        t.join
+      end
+
+      test_state(:worker_stop).should == 3
+    end
+
+    it 'raises SystemExit when all workers exit with specified code by unrecoverable_exit_codes' do
+      pending "unrecoverable_exit_codes supported only for multi process workers" if impl_class == ServerEngine::MultiThreadServer
+      pending "Windows environment does not support fork" if ServerEngine.windows? && impl_class == ServerEngine::MultiProcessServer
+
+      config = {workers: 4, log_stdout: false, log_stderr: false, unrecoverable_exit_codes: [3, 4, 5]}
+
+      s = impl_class.new(TestExitWorker) { config.dup }
+      raised_error = nil
+      t = Thread.new do
+        begin
+          s.main
+        rescue SystemExit => e
+          raised_error = e
+        end
+      end
+
+      wait_for_fork
+      test_state(:worker_run).should == 4
+      t.join
+
+      test_state(:worker_stop).to_i.should == 0
+      raised_error.status.should == 3 # 4th process's exit status
+    end
+
+    it 'raises SystemExit immediately when a worker exits if stop_immediately_at_unrecoverable_exit specified' do
+      pending "unrecoverable_exit_codes supported only for multi process workers" if impl_class == ServerEngine::MultiThreadServer
+      pending "Windows environment does not support fork" if ServerEngine.windows? && impl_class == ServerEngine::MultiProcessServer
+
+      config = {workers: 4, log_stdout: false, log_stderr: false, unrecoverable_exit_codes: [3, 4, 5], stop_immediately_at_unrecoverable_exit: true}
+
+      s = impl_class.new(TestExitWorker) { config.dup }
+      raised_error = nil
+      t = Thread.new do
+        begin
+          s.main
+        rescue SystemExit => e
+          raised_error = e
+        end
+      end
+
+      wait_for_fork
+      test_state(:worker_run).should == 4
+      t.join
+
+      test_state(:worker_stop).to_i.should == 3
+      test_state(:worker_finished).to_i.should == 3
+      raised_error.should_not be_nil
+      raised_error.status.should == 5 # 1st process's exit status
+    end
+  end
+end

data/spec/server_worker_context.rb

@@ -0,0 +1,232 @@
+
+require 'thread'
+require 'yaml'
+
+def reset_test_state
+  FileUtils.mkdir_p 'tmp'
+  FileUtils.rm_f 'tmp/state.yml'
+  FileUtils.touch 'tmp/state.yml'
+  $state_file_mutex = Mutex.new
+  if ServerEngine.windows?
+    open("tmp/daemon.rb", "w") do |f|
+      f.puts <<-'end_of_script'
+require "serverengine"
+require "rspec"
+$state_file_mutex = Mutex.new # TODO
+require "server_worker_context"
+include ServerEngine
+command_pipe = STDIN.dup
+STDIN.reopen(File::NULL)
+Daemon.run_server(TestServer, TestWorker, command_pipe: command_pipe)
+      end_of_script
+    end
+
+    open("tmp/supervisor.rb", "w") do |f|
+      f.puts <<-'end_of_script'
+require "serverengine"
+require "rspec"
+$state_file_mutex = Mutex.new # TODO
+require "server_worker_context"
+include ServerEngine
+server = TestServer
+worker = TestWorker
+config = {command_pipe: STDIN.dup}
+STDIN.reopen(File::NULL)
+ARGV.each do |arg|
+  case arg
+  when /^server=(.*)$/
+    server = Object.const_get($1)
+  when /^worker=(.*)$/
+    worker = Object.const_get($1)
+  when /^(.*)=(\d+)$/
+    config[$1.to_sym] = $2.to_i
+  when /^(.*)=(.*)$/
+    config[$1.to_sym] = $2
+  else
+    raise "Unknown parameter: [#{arg}]"
+  end
+end
+sv = Supervisor.new(server, worker, config)
+s = sv.create_server(nil)
+s.install_signal_handlers
+t = Thread.new{ s.main }
+s.after_start
+t.join
+      end_of_script
+    end
+  end
+end
+
+def windows_daemon_cmdline
+  if ServerEngine.windows?
+    [ServerEngine.ruby_bin_path, '-I', File.dirname(__FILE__), 'tmp/daemon.rb']
+  else
+    nil
+  end
+end
+
+def windows_supervisor_cmdline(server = nil, worker = nil, config = {})
+  if ServerEngine.windows?
+    cmd = [ServerEngine.ruby_bin_path, '-I', File.dirname(__FILE__), 'tmp/supervisor.rb']
+    cmd << "server=#{server}" if server
+    cmd << "worker=#{worker}" if worker
+    config.each_pair do |k, v|
+      cmd << "#{k}=#{v}"
+    end
+    cmd
+  else
+    nil
+  end
+end
+
+def incr_test_state(key)
+  File.open('tmp/state.yml', 'r+') do |f|
+    f.flock(File::LOCK_EX)
+
+    $state_file_mutex.synchronize do
+      data = YAML.load(f.read) || {} rescue {}
+      data[key] ||= 0
+      data[key] += 1
+
+      f.pos = 0
+      f.write YAML.dump(data)
+      data[key]
+    end
+  end
+end
+
+def test_state(key)
+  data = YAML.load_file('tmp/state.yml') || {} rescue {}
+  return data[key] || 0
+end
+
+module TestServer
+  def initialize
+    incr_test_state :server_initialize
+  end
+
+  def before_run
+    incr_test_state :server_before_run
+  end
+
+  def after_run
+    incr_test_state :server_after_run
+  end
+
+  def after_start
+    incr_test_state :server_after_start
+  end
+
+  def stop(stop_graceful)
+    incr_test_state :server_stop
+    if stop_graceful
+      incr_test_state :server_stop_graceful
+    else
+      incr_test_state :server_stop_immediate
+    end
+    super
+  end
+
+  def restart(stop_graceful)
+    incr_test_state :server_restart
+    if stop_graceful
+      incr_test_state :server_restart_graceful
+    else
+      incr_test_state :server_restart_immediate
+    end
+    super
+  end
+
+  def reload
+    incr_test_state :server_reload
+    super
+  end
+
+  def detach
+    incr_test_state :server_detach
+    super
+  end
+end
+
+module TestWorker
+  def initialize
+    incr_test_state :worker_initialize
+    @stop_flag = BlockingFlag.new
+  end
+
+  def before_fork
+    incr_test_state :worker_before_fork
+  end
+
+  def run
+    incr_test_state :worker_run
+    5.times do
+      # repeats 5 times because signal handlers
+      # interrupts wait
+      @stop_flag.wait(5.0)
+    end
+    @stop_flag.reset!
+  end
+
+  def stop
+    incr_test_state :worker_stop
+    @stop_flag.set!
+  end
+
+  def reload
+    incr_test_state :worker_reload
+  end
+
+  def after_start
+    incr_test_state :worker_after_start
+  end
+end
+
+module RunErrorWorker
+  def run
+    incr_test_state :worker_run
+    raise StandardError, "error test"
+  end
+end
+
+module TestExitWorker
+  def initialize
+    @stop_flag = BlockingFlag.new
+    @worker_num = incr_test_state :worker_initialize
+    @exit_code = case @worker_num
+                 when 1 then 5
+                 when 4 then 3
+                 else 4
+                 end
+  end
+
+  def run
+    incr_test_state :worker_run
+    exit_at = Time.now + @worker_num * 2
+    until @stop_flag.wait(0.1)
+      exit!(@exit_code) if Time.now >= exit_at
+    end
+    incr_test_state :worker_finished
+  end
+
+  def stop
+    incr_test_state :worker_stop
+    @stop_flag.set!
+  end
+end
+
+shared_context 'test server and worker' do
+  before { reset_test_state }
+
+  def wait_for_fork
+    sleep 0.8
+  end
+
+  def wait_for_stop
+    sleep 0.8
+  end
+
+  def wait_for_restart
+    sleep 1.5
+  end
+end