serverengine 2.2.5 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2175217415cd5751a1bd4a8d60c5abdb64e80429e722c41e8c1e97ec02b1e22a
-  data.tar.gz: 63a7af53a0dc906bb962394f902d1486f7958950c9b3b9bf41206e56789d83ad
+  metadata.gz: 8b802588a6e93b69c2dc9810ab33b9e3195e14d93c5f977961a04cc6d88cacf1
+  data.tar.gz: 9921383ec5ae39cfe982da9ce8c0b432bbc553c2ea5d2090a2d849ec2500c230
 SHA512:
-  metadata.gz: 85880cc1ec9b83e03b2cbe80756253e156e46954117ae0a008388bfccf3d412b96a54911f9f002b6387ec2dfa9ef35dd3a40bff1dff22f7b5ca180f667d88611
-  data.tar.gz: 624a1e6397faa39af9b871ef91571b432263d6b2b595fc4bdfaa9244a6153b25a67fe80c38c6f814c94db27b0dddcc1e4e19ae08515c8e48c2ee6208478775d0
+  metadata.gz: ea4c0e4b34490665e4287c0f43e4ea1f32c10fe022464a69326505ec21aad2650e53b842c2aaeec2a969d914f73715ee059b2bdbb3d72d14b0bce51192bf217c
+  data.tar.gz: 3e30810b08b8667f2295b41fca60c4683126d8936e32169d0789b8ec02ba3965fc631dbe069c9a8cf057e109ccaa9ad3ad14f4507b2388dcd9ae27463ce39651

data/.github/workflows/linux.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.1', '3.0', '2.7', '2.6' ]
+        ruby: [ '3.1', '3.0', '2.7' ]
         os:
           - ubuntu-latest
     name: Unit testing with Ruby ${{ matrix.ruby }} on ${{ matrix.os }}

data/.github/workflows/windows.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.1', '2.7', '2.6' ]
+        ruby: [ '3.1', '2.7' ]
         os:
           - windows-latest
         include:

data/Changelog

@@ -1,6 +1,23 @@
+2022-12-22 version 2.3.1
+
+* Don't treat as error when worker shuts down with exit status 0
+
+2022-06-13 version 2.3.0
+
+* Add restart_worker_interval option to prevent workers restart immediately
+  after kill
+* Reopen log file when rotation done by external tool is detected
+* Fix unexpected behavior of start_worker_delay option
+* Remove windows-pr dependency
+* Fix a potential crash that command_sender_pipe of ProcessManager::Monitor
+  raises error on shutdown
+* Allow to load serverengine/socket_manager without servernegine/utils
+* Fix unstable tests
+
 2022-01-13 version 2.2.5:
 
 * Fix DLL load error on Ruby 3.1 on Windows
+* Treat as error when worker shuts down unexpectedly
 
 2021-05-24 version 2.2.4:
 

data/README.md

@@ -478,10 +478,11 @@ Available methods are different depending on `worker_type`. ServerEngine support
   - **disable_reload** disables USR2 signal (default: false)
   - **server_restart_wait** sets wait time before restarting server after last restarting (default: 1.0) [dynamic reloadable]
   - **server_detach_wait** sets wait time before starting live restart (default: 10.0) [dynamic reloadable]
-- Multithread server and multiprocess server: available only when `worker_type` is thread or process
+- Multithread server and multiprocess server: available only when `worker_type` is "thread" or "process" or "spawn"
   - **workers** sets number of workers (default: 1) [dynamic reloadable]
-  - **start_worker_delay** sets wait time before starting a new worker (default: 0) [dynamic reloadable]
+  - **start_worker_delay** sets the delay between each worker-start when starting/restarting multiple workers at once (default: 0) [dynamic reloadable]
   - **start_worker_delay_rand** randomizes start_worker_delay at this ratio (default: 0.2) [dynamic reloadable]
+  - **restart_worker_interval** sets wait time before restarting a stopped worker (default: 0) [dynamic reloadable]
 - Multiprocess server: available only when `worker_type` is "process"
   - **worker_process_name** changes process name ($0) of workers [dynamic reloadable]
   - **worker_heartbeat_interval** sets interval of heartbeats in seconds (default: 1.0) [dynamic reloadable]

data/Rakefile

@@ -8,19 +8,3 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 task :default => [:spec, :build]
-
-# 1. update Changelog and lib/serverengine/version.rb
-# 2. bundle && bundle exec rake build:all
-# 3. release 3 packages built on pkg/ directory
-namespace :build do
-  desc 'Build gems for all platforms'
-  task :all do
-    Bundler.with_clean_env do
-      %w[ruby x86-mingw32 x64-mingw32].each do |name|
-        ENV['GEM_BUILD_FAKE_PLATFORM'] = name
-        Rake::Task["build"].execute
-      end
-    end
-  end
-end
-

data/lib/serverengine/daemon_logger.rb

@@ -55,6 +55,9 @@ module ServerEngine
         # update path string
         old_file_dev = @file_dev
         @file_dev = LogDevice.new(logdev, shift_age: @rotate_age, shift_size: @rotate_size)
+        # Enable to detect rotation done by external tools.
+        # Otherwise it continues writing logs to old file unexpectedly.
+        @file_dev.extend(RotationAware)
         old_file_dev.close if old_file_dev
         @logdev = @file_dev
       end
@@ -130,6 +133,40 @@ module ServerEngine
       nil
     end
 
+    module RotationAware
+      def self.extended(obj)
+        obj.update_ino
+      end
+
+      def update_ino
+        (@ino_mutex ||= Mutex.new).synchronize do
+          @ino = File.stat(filename).ino rescue nil
+          @last_ino_time = Time.now
+        end
+      end
+
+      def reopen(log = nil)
+        super(log)
+        update_ino
+      end
+
+      def reopen!
+        super
+        update_ino
+      end
+
+      def write(message)
+        reopen_needed = false
+        @ino_mutex.synchronize do
+          if (Time.now - @last_ino_time).abs > 1
+            ino = File.stat(filename).ino rescue nil
+            reopen_needed = true if ino && ino != @ino
+          end
+        end
+        reopen! if reopen_needed
+        super(message)
+      end
+    end
   end
 
 end

data/lib/serverengine/multi_process_server.rb

@@ -105,9 +105,11 @@ module ServerEngine
         @unrecoverable_exit_codes = unrecoverable_exit_codes
         @unrecoverable_exit = false
         @exitstatus = nil
+        @restart_at = nil
       end
 
       attr_reader :exitstatus
+      attr_accessor :restart_at
 
       def send_stop(stop_graceful)
         @stop = true
@@ -145,7 +147,11 @@ module ServerEngine
           if @stop
             @worker.logger.info "Worker #{@wid} finished with #{ServerEngine.format_join_status(stat)}"
           else
-            @worker.logger.error "Worker #{@wid} finished unexpectedly with #{ServerEngine.format_join_status(stat)}"
+            if stat.is_a?(Process::Status) && stat.success?
+              @worker.logger.info "Worker #{@wid} exited with #{ServerEngine.format_join_status(stat)}"
+            else
+              @worker.logger.error "Worker #{@wid} exited unexpectedly with #{ServerEngine.format_join_status(stat)}"
+            end
           end
           if stat.is_a?(Process::Status) && stat.exited? && @unrecoverable_exit_codes.include?(stat.exitstatus)
             @unrecoverable_exit = true

data/lib/serverengine/multi_thread_server.rb

@@ -39,8 +39,11 @@ module ServerEngine
       def initialize(worker, thread)
         @worker = worker
         @thread = thread
+        @restart_at = nil
       end
 
+      attr_accessor :restart_at
+
       def send_stop(stop_graceful)
         Thread.new do
           begin

data/lib/serverengine/multi_worker_server.rb

@@ -55,8 +55,8 @@ module ServerEngine
 
     def run
       while true
-        num_alive = keepalive_workers
-        break if num_alive == 0
+        num_alive_or_restarting = keepalive_workers
+        break if num_alive_or_restarting == 0
         wait_tick
       end
     end
@@ -85,6 +85,7 @@ module ServerEngine
 
       @start_worker_delay = @config[:start_worker_delay] || 0
       @start_worker_delay_rand = @config[:start_worker_delay_rand] || 0.2
+      @restart_worker_interval = @config[:restart_worker_interval] || 0
 
       scale_workers(@config[:workers] || 1)
 
@@ -96,12 +97,12 @@ module ServerEngine
     end
 
     def keepalive_workers
-      num_alive = 0
+      num_alive_or_restarting = 0
 
       @monitors.each_with_index do |m,wid|
         if m && m.alive?
           # alive
-          num_alive += 1
+          num_alive_or_restarting += 1
 
         elsif m && m.respond_to?(:recoverable?) && !m.recoverable?
           # exited, with unrecoverable exit code
@@ -116,8 +117,12 @@ module ServerEngine
         elsif wid < @num_workers
           # scale up or reboot
           unless @stop
-            @monitors[wid] = delayed_start_worker(wid)
-            num_alive += 1
+            if m
+              restart_worker(wid)
+            else
+              start_new_worker(wid)
+            end
+            num_alive_or_restarting += 1
           end
 
         elsif m
@@ -126,7 +131,27 @@ module ServerEngine
         end
       end
 
-      return num_alive
+      return num_alive_or_restarting
+    end
+
+    def start_new_worker(wid)
+      delayed_start_worker(wid)
+    end
+
+    def restart_worker(wid)
+      m = @monitors[wid]
+
+      is_already_restarting = !m.restart_at.nil?
+      if is_already_restarting
+        delayed_start_worker(wid) if m.restart_at <= Time.now()
+        return
+      end
+
+      if @restart_worker_interval > 0
+        m.restart_at = Time.now() + @restart_worker_interval
+      else
+        delayed_start_worker(wid)
+      end
     end
 
     def delayed_start_worker(wid)
@@ -135,15 +160,13 @@ module ServerEngine
           Kernel.rand * @start_worker_delay * @start_worker_delay_rand -
           @start_worker_delay * @start_worker_delay_rand / 2
 
-        now = Time.now.to_f
-
-        wait = delay - (now - @last_start_worker_time)
+        wait = delay - (Time.now.to_f - @last_start_worker_time)
         sleep wait if wait > 0
 
-        @last_start_worker_time = now
+        @last_start_worker_time = Time.now.to_f
       end
 
-      start_worker(wid)
+      @monitors[wid] = start_worker(wid)
     end
   end
 

data/lib/serverengine/process_manager.rb

@@ -333,7 +333,15 @@ module ServerEngine
       end
 
       def send_command(command)
-        @command_sender_pipe.write(command) if @command_sender_pipe
+        pid = @pid
+        return false unless pid
+
+        begin
+          @command_sender_pipe.write(command)
+          return true
+        rescue #Errno::EPIPE
+          return false
+        end
       end
 
       def try_join

data/lib/serverengine/server.rb

@@ -80,7 +80,7 @@ module ServerEngine
       if @command_pipe
         Thread.new do
           until @command_pipe.closed?
-            case @command_pipe.gets.chomp
+            case @command_pipe.gets&.chomp
             when "GRACEFUL_STOP"
               s.stop(true)
             when "IMMEDIATE_STOP"

data/lib/serverengine/socket_manager.rb

@@ -22,6 +22,8 @@ require 'securerandom'
 require 'json'
 require 'base64'
 
+require_relative 'utils' # for ServerEngine.windows?
+
 module ServerEngine
   module SocketManager
     # This token is used for communication between peers. If token is mismatched, messages will be discarded

data/lib/serverengine/version.rb

@@ -1,3 +1,3 @@
 module ServerEngine
-  VERSION = "2.2.5"
+  VERSION = "2.3.1"
 end

data/lib/serverengine/winsock.rb

@@ -99,7 +99,6 @@ module ServerEngine
     extend Fiddle::Importer
 
     dlload "kernel32"
-    extern "int GetModuleFileNameA(int, char *, int)"
     extern "int CloseHandle(int)"
 
     dlload RbConfig::CONFIG['LIBRUBY_SO']

data/lib/serverengine.rb

@@ -35,12 +35,27 @@ module ServerEngine
 
   def self.ruby_bin_path
     if ServerEngine.windows?
-      require 'windows/library'
-      ruby_path = "\0" * 256
-      Windows::Library::GetModuleFileName.call(0, ruby_path, 256)
-      return ruby_path.rstrip.gsub(/\\/, '/')
+      ServerEngine::Win32.ruby_bin_path
     else
-      return File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["RUBY_INSTALL_NAME"]) + RbConfig::CONFIG["EXEEXT"]
+      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["RUBY_INSTALL_NAME"]) + RbConfig::CONFIG["EXEEXT"]
+    end
+  end
+
+  if ServerEngine.windows?
+    module Win32
+      require 'fiddle/import'
+
+      extend Fiddle::Importer
+
+      dlload "kernel32"
+      extern "int GetModuleFileNameW(int, void *, int)"
+
+      def self.ruby_bin_path
+        ruby_bin_path_buf = Fiddle::Pointer.malloc(1024)
+        len = GetModuleFileNameW(0, ruby_bin_path_buf, ruby_bin_path_buf.size / 2)
+        path_bytes = ruby_bin_path_buf[0, len * 2]
+        path_bytes.encode('UTF-8', 'UTF-16LE').gsub(/\\/, '/')
+      end
     end
   end
 end

data/serverengine.gemspec

@@ -27,11 +27,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake-compiler-dock', ['~> 0.5.0']
   gem.add_development_dependency 'rake-compiler', ['~> 0.9.4']
 
-  # build gem for a certain platform. see also Rakefile
-  fake_platform = ENV['GEM_BUILD_FAKE_PLATFORM'].to_s
-  gem.platform = fake_platform unless fake_platform.empty?
-  if /mswin|mingw/ =~ fake_platform || (/mswin|mingw/ =~ RUBY_PLATFORM && fake_platform.empty?)
-    # windows dependencies
-    gem.add_runtime_dependency("windows-pr", ["~> 1.2.5"])
-  end
+  gem.add_development_dependency "timecop", ["~> 0.9.5"]
+  gem.add_development_dependency "rr", ["~> 3.1"]
 end

data/spec/daemon_logger_spec.rb

@@ -1,4 +1,5 @@
 require 'stringio'
+require 'timecop'
 
 describe ServerEngine::DaemonLogger do
   before { FileUtils.rm_rf("tmp") }
@@ -172,4 +173,28 @@ describe ServerEngine::DaemonLogger do
     $stderr = STDERR
     stderr.should_not =~ /(log shifting failed|log writing failed|log rotation inter-process lock failed)/
   end
+
+  it 'reopen log when path is renamed' do
+    pending "rename isn't supported on windows" if ServerEngine.windows?
+
+    log = DaemonLogger.new("tmp/rotate.log", { level: 'info', log_rotate_age: 0  })
+
+    log.info '11111'
+    File.read("tmp/rotate.log").should include('11111')
+    File.rename("tmp/rotate.log", "tmp/rotate.log.1")
+
+    Timecop.travel(Time.now + 1)
+
+    log.info '22222'
+    contents = File.read("tmp/rotate.log.1")
+    contents.should include('11111')
+    contents.should include('22222')
+
+    FileUtils.touch("tmp/rotate.log")
+    Timecop.travel(Time.now + 1)
+
+    log.info '33333'
+    File.read("tmp/rotate.log").should include('33333')
+    File.read("tmp/rotate.log.1").should_not include('33333')
+  end
 end

data/spec/daemon_spec.rb

@@ -2,6 +2,14 @@
 describe ServerEngine::Daemon do
   include_context 'test server and worker'
 
+  before do
+    @log_path = "tmp/multi-worker-test-#{SecureRandom.hex(10)}.log"
+  end
+
+  after do
+    FileUtils.rm_rf(@log_path)
+  end
+
   it 'run and graceful stop by signal' do
     pending "not supported signal base commands on Windows" if ServerEngine.windows?
 
@@ -111,6 +119,7 @@ describe ServerEngine::Daemon do
       daemonize: false,
       supervisor: false,
       pid_path: "tmp/pid",
+      logger: ServerEngine::DaemonLogger.new(@log_path),
       log_stdout: false,
       log_stderr: false,
       unrecoverable_exit_codes: [3,4,5],
@@ -135,6 +144,7 @@ describe ServerEngine::Daemon do
       supervisor: false,
       worker_type: 'process',
       pid_path: "tmp/pid",
+      logger: ServerEngine::DaemonLogger.new(@log_path),
       log_stdout: false,
       log_stderr: false,
       unrecoverable_exit_codes: [3,4,5],
@@ -158,6 +168,7 @@ describe ServerEngine::Daemon do
       supervisor: true,
       worker_type: 'process',
       pid_path: "tmp/pid",
+      logger: ServerEngine::DaemonLogger.new(@log_path),
       log_stdout: false,
       log_stderr: false,
       unrecoverable_exit_codes: [3,4,5],

data/spec/multi_process_server_spec.rb

@@ -1,13 +1,30 @@
+require 'timeout'
+require 'securerandom'
+
 [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'
 
+    before do
+      @log_path = "tmp/multi-worker-test-#{SecureRandom.hex(10)}.log"
+      @logger = ServerEngine::DaemonLogger.new(@log_path)
+    end
+
+    after do
+      FileUtils.rm_rf(@log_path)
+    end
+
     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}
+      config = {
+        workers: 2,
+        logger: @logger,
+        log_stdout: false,
+        log_stderr: false,
+      }
 
       s = impl_class.new(TestWorker) { config.dup }
       t = Thread.new { s.main }
@@ -35,7 +52,12 @@
     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}
+      config = {
+        workers: 2,
+        logger: @logger,
+        log_stdout: false,
+        log_stderr: false
+      }
 
       s = impl_class.new(TestWorker) { config.dup }
       t = Thread.new { s.main }
@@ -59,12 +81,32 @@
 
       test_state(:worker_stop).should == 3
     end
+  end
+end
+
+[ServerEngine::MultiProcessServer].each do |impl_class|
+  describe impl_class do
+    include_context 'test server and worker'
+
+    before do
+      @log_path = "tmp/multi-worker-test-#{SecureRandom.hex(10)}.log"
+      @logger = ServerEngine::DaemonLogger.new(@log_path)
+    end
+
+    after do
+      FileUtils.rm_rf(@log_path)
+    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]}
+      config = {
+        workers: 4,
+        logger: @logger,
+        log_stdout: false,
+        log_stderr: false,
+        unrecoverable_exit_codes: [3, 4, 5]
+      }
 
       s = impl_class.new(TestExitWorker) { config.dup }
       raised_error = nil
@@ -85,10 +127,16 @@
     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}
+      config = {
+        workers: 4,
+        logger: @logger,
+        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
@@ -111,3 +159,101 @@
     end
   end
 end
+
+describe "log level for exited proccess" do
+  include_context 'test server and worker'
+
+  before do
+    @log_path = "tmp/multi-process-log-level-test-#{SecureRandom.hex(10)}.log"
+  end
+
+  after do
+    FileUtils.rm_rf(@log_path)
+  end
+
+  it 'stop' do
+    pending "Windows environment does not support fork" if ServerEngine.windows?
+
+    config = {
+      workers: 1,
+      logger: ServerEngine::DaemonLogger.new(@log_path),
+      log_stdout: false,
+      log_stderr: false,
+    }
+
+    s = ServerEngine::MultiProcessServer.new(TestWorker) { config.dup }
+    t = Thread.new { s.main }
+
+    begin
+      wait_for_fork
+      test_state(:worker_run).should == 1
+    ensure
+      s.stop(true)
+      t.join
+    end
+
+    log_lines = File.read(@log_path).split("\n")
+    expect(log_lines[2]).to match(/^I, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d+ #\d+\]  INFO -- : Worker 0 finished with status 0$/)
+  end
+
+  it 'non zero exit status' do
+    pending "Windows environment does not support fork" if ServerEngine.windows?
+
+    config = {
+      workers: 1,
+      logger: ServerEngine::DaemonLogger.new(@log_path),
+      log_stdout: false,
+      log_stderr: false,
+      unrecoverable_exit_codes: [5],
+    }
+
+    s = ServerEngine::MultiProcessServer.new(TestExitWorker) { config.dup }
+    raised_error = nil
+    Thread.new do
+      begin
+        s.main
+      rescue SystemExit => e
+        raised_error = e
+      end
+    end.join
+
+    test_state(:worker_stop).to_i.should == 0
+    raised_error.status.should == 5
+    log_lines = File.read(@log_path).split("\n")
+    expect(log_lines[1]).to match(/^E, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d+ #\d+\] ERROR -- : Worker 0 exited unexpectedly with status 5$/)
+  end
+
+  module TestNormalExitWorker
+    include TestExitWorker
+    def initialize
+      super
+      @exit_code = 0
+    end
+  end
+
+  it 'zero exit status' do
+    pending "Windows environment does not support fork" if ServerEngine.windows?
+
+    config = {
+      workers: 1,
+      logger: ServerEngine::DaemonLogger.new(@log_path),
+      log_stdout: false,
+      log_stderr: false,
+    }
+
+    s = ServerEngine::MultiProcessServer.new(TestNormalExitWorker) { config.dup }
+    t = Thread.new { s.main }
+
+    begin
+      Timeout.timeout(5) do
+        sleep 1 until File.read(@log_path).include?("INFO -- : Worker 0 exited with status 0")
+      end
+    ensure
+      s.stop(true)
+      t.join
+    end
+
+    log_lines = File.read(@log_path).split("\n")
+    expect(log_lines[1]).to match(/^I, \[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d+ #\d+\]  INFO -- : Worker 0 exited with status 0$/)
+  end
+end

data/spec/multi_spawn_server_spec.rb

@@ -1,25 +1,224 @@
 require 'timeout'
+require 'timecop'
 
 describe ServerEngine::MultiSpawnServer do
   include_context 'test server and worker'
 
-  context 'with command_sender=pipe' do
-    it 'starts worker processes' do
-      config = {workers: 2, command_sender: 'pipe', log_stdout: false, log_stderr: false}
+  before do
+    @log_path = "tmp/multi-worker-test-#{SecureRandom.hex(10)}.log"
+    @logger = ServerEngine::DaemonLogger.new(@log_path)
+  end
+
+  after do
+    FileUtils.rm_rf(@log_path)
+  end
+
+  describe 'starts worker processes' do
+    context 'with command_sender=pipe' do
+      it do
+        config = {
+          workers: 2,
+          command_sender: 'pipe',
+          logger: @logger,
+          log_stdout: false,
+          log_stderr: false
+        }
+
+        s = ServerEngine::MultiSpawnServer.new(TestWorker) { config.dup }
+        t = Thread.new { s.main }
+
+        begin
+          wait_for_fork
+
+          Timeout.timeout(5) do
+            sleep(0.5) until test_state(:worker_run) == 2
+          end
+          test_state(:worker_run).should == 2
+        ensure
+          s.stop(true)
+          t.join
+        end
+      end
+    end
+  end
+
+  describe 'keepalive_workers' do
+    let(:config) {
+      {
+        workers: workers,
+        command_sender: 'pipe',
+        logger: @logger,
+        log_stdout: false,
+        log_stderr: false,
+        start_worker_delay: start_worker_delay,
+        start_worker_delay_rand: 0,
+        restart_worker_interval: restart_worker_interval,
+      }
+    }
+    let(:workers) { 3 }
+    let(:server) { ServerEngine::MultiSpawnServer.new(TestWorker) { config.dup } }
+    let(:monitors) { server.instance_variable_get(:@monitors) }
+
+    context 'default' do
+      let(:start_worker_delay) { 0 }
+      let(:restart_worker_interval) { 0 }
+
+      it do
+        t = Thread.new { server.main }
+
+        begin
+          wait_for_fork
+
+          Timeout.timeout(5) do
+            sleep(0.5) until monitors.count { |m| m && m.alive? } == workers
+          end
+
+          monitors.each do |m|
+            m.send_stop(true)
+          end
+
+          # To prevent the judge before stopping once
+          wait_for_stop
+
+          -> {
+            Timeout.timeout(5) do
+              sleep(0.5) until monitors.count { |m| m.alive? } == workers
+            end
+          }.should_not raise_error, "Not all workers restarted correctly."
+        ensure
+          server.stop(true)
+          t.join
+        end
+      end
+    end
+
+    context 'with only restart_worker_interval' do
+      let(:start_worker_delay) { 0 }
+      let(:restart_worker_interval) { 10 }
+
+      it do
+        t = Thread.new { server.main }
+
+        begin
+          wait_for_fork
+
+          # Wait for initial starting
+          Timeout.timeout(5) do
+            sleep(0.5) until monitors.count { |m| m && m.alive? } == workers
+          end
+
+          monitors.each do |m|
+            m.send_stop(true)
+          end
+
+          # Wait for all workers to stop and to be set restarting time
+          Timeout.timeout(5) do
+            sleep(0.5) until monitors.count { |m| m.alive? || m.restart_at.nil? } == 0
+          end
+
+          Timecop.freeze
+
+          mergin_time = 3
+
+          Timecop.freeze(Time.now + restart_worker_interval - mergin_time)
+          sleep(1.5)
+          monitors.count { |m| m.alive? }.should == 0
+
+          Timecop.freeze(Time.now + 2 * mergin_time)
+          -> {
+            Timeout.timeout(5) do
+              sleep(0.5) until monitors.count { |m| m.alive? } == workers
+            end
+          }.should_not raise_error, "Not all workers restarted correctly."
+        ensure
+          server.stop(true)
+          t.join
+        end
+      end
+    end
+
+    context 'with only start_worker_delay' do
+      let(:start_worker_delay) { 3 }
+      let(:restart_worker_interval) { 0 }
+
+      it do
+        t = Thread.new { server.main }
+
+        begin
+          wait_for_fork
+
+          # Initial starts are delayed too, so set longer timeout.
+          # (`start_worker_delay` uses `sleep` inside, so Timecop can't skip this wait.)
+          Timeout.timeout(start_worker_delay * workers) do
+            sleep(0.5) until monitors.count { |m| m && m.alive? } == workers
+          end
+
+          # Skip time to avoid getting a delay for the initial starts.
+          Timecop.travel(Time.now + start_worker_delay)
+
+          monitors.each do |m|
+            m.send_stop(true)
+          end
+
+          sleep(3)
+
+          # The first worker should restart immediately.
+          monitors.count { |m| m.alive? }.should satisfy { |c| 0 < c && c < workers }
+
+          # `start_worker_delay` uses `sleep` inside, so Timecop can't skip this wait.
+          sleep(start_worker_delay * workers)
+          monitors.count { |m| m.alive? }.should == workers
+        ensure
+          server.stop(true)
+          t.join
+        end
+      end
+    end
+
+    context 'with both options' do
+      let(:start_worker_delay) { 3 }
+      let(:restart_worker_interval) { 10 }
+
+      it do
+        t = Thread.new { server.main }
+
+        begin
+          wait_for_fork
+
+          # Initial starts are delayed too, so set longer timeout.
+          # (`start_worker_delay` uses `sleep` inside, so Timecop can't skip this wait.)
+          Timeout.timeout(start_worker_delay * workers) do
+            sleep(0.5) until monitors.count { |m| m && m.alive? } == workers
+          end
+
+          monitors.each do |m|
+            m.send_stop(true)
+          end
+
+          # Wait for all workers to stop and to be set restarting time
+          Timeout.timeout(5) do
+            sleep(0.5) until monitors.count { |m| m.alive? || m.restart_at.nil? } == 0
+          end
+
+          Timecop.freeze
+
+          mergin_time = 3
 
-      s = ServerEngine::MultiSpawnServer.new(TestWorker) { config.dup }
-      t = Thread.new { s.main }
+          Timecop.freeze(Time.now + restart_worker_interval - mergin_time)
+          sleep(1.5)
+          monitors.count { |m| m.alive? }.should == 0
 
-      begin
-        wait_for_fork
+          Timecop.travel(Time.now + 2 * mergin_time)
+          sleep(1.5)
+          monitors.count { |m| m.alive? }.should satisfy { |c| 0 < c && c < workers }
 
-        Timeout.timeout(5) do
-          sleep(0.5) until test_state(:worker_run) == 2
+          # `start_worker_delay` uses `sleep` inside, so Timecop can't skip this wait.
+          sleep(start_worker_delay * workers)
+          monitors.count { |m| m.alive? }.should == workers
+        ensure
+          server.stop(true)
+          t.join
         end
-        test_state(:worker_run).should == 2
-      ensure
-        s.stop(true)
-        t.join
       end
     end
   end

data/spec/server_worker_context.rb

@@ -1,6 +1,7 @@
 
 require 'thread'
 require 'yaml'
+require 'timecop'
 
 def reset_test_state
   FileUtils.mkdir_p 'tmp'
@@ -165,8 +166,9 @@ module TestWorker
 
   def run
     incr_test_state :worker_run
-    5.times do
-      # repeats 5 times because signal handlers
+    # This means this worker will automatically finish after 50 seconds.
+    10.times do
+      # repeats multiple times because signal handlers
       # interrupts wait
       @stop_flag.wait(5.0)
     end
@@ -252,16 +254,25 @@ end
 
 shared_context 'test server and worker' do
   before { reset_test_state }
+  after { Timecop.return }
+
+  unless self.const_defined?(:WAIT_RATIO)
+    if ServerEngine.windows?
+      WAIT_RATIO = 2
+    else
+      WAIT_RATIO = 1
+    end
+  end
 
   def wait_for_fork
-    sleep 1.5
+    sleep 1.5 * WAIT_RATIO
   end
 
   def wait_for_stop
-    sleep 0.8
+    sleep 0.8 * WAIT_RATIO
   end
 
   def wait_for_restart
-    sleep 1.5
+    sleep 1.5 * WAIT_RATIO
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,9 @@
 require 'bundler'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
 
 begin
   Bundler.setup(:default, :test)

data/spec/supervisor_spec.rb

@@ -1,8 +1,12 @@
+require 'rr'
 
 describe ServerEngine::Supervisor do
   include_context 'test server and worker'
 
   def start_supervisor(worker = nil, **config)
+    config[:log] ||= @log_path
+    config[:log_stdout] ||= false
+    config[:log_stderr] ||= false
     if ServerEngine.windows?
       config[:windows_daemon_cmdline] = windows_supervisor_cmdline(nil, worker, config)
     end
@@ -13,6 +17,8 @@ describe ServerEngine::Supervisor do
   end
 
   def start_daemon(**config)
+    config[:log_stdout] ||= false
+    config[:log_stderr] ||= false
     if ServerEngine.windows?
       config[:windows_daemon_cmdline] = windows_daemon_cmdline
     end
@@ -22,9 +28,17 @@ describe ServerEngine::Supervisor do
     return daemon, t
   end
 
+  before do
+    @log_path = "tmp/supervisor-test-#{SecureRandom.hex(10)}.log"
+  end
+
+  after do
+    FileUtils.rm_rf(@log_path)
+  end
+
   context 'when :log=IO option is given' do
     it 'can start' do
-      daemon, t = start_daemon(log: STDOUT)
+      daemon, t = start_daemon(log: File.open(@log_path, "wb"))
 
       begin
         wait_for_fork
@@ -40,7 +54,7 @@ describe ServerEngine::Supervisor do
 
   context 'when :logger option is given' do
     it 'uses specified logger instance' do
-      logger = ServerEngine::DaemonLogger.new(STDOUT)
+      logger = ServerEngine::DaemonLogger.new(@log_path)
       daemon, t = start_daemon(logger: logger)
 
       begin
@@ -57,7 +71,7 @@ describe ServerEngine::Supervisor do
 
   context 'when both :logger and :log options are given' do
     it 'start ignoring :log' do
-      logger = ServerEngine::DaemonLogger.new(STDOUT)
+      logger = ServerEngine::DaemonLogger.new(@log_path)
       daemon, t = start_daemon(logger: logger, log: STDERR)
 
       begin
@@ -188,6 +202,8 @@ describe ServerEngine::Supervisor do
       it 'auto restart in limited ratio' do
         pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
 
+        RR.stub(ServerEngine).dump_uncaught_error
+
         sv, t = start_supervisor(RunErrorWorker, server_restart_wait: 1, command_sender: sender)
 
         begin

data/spec/winsock_spec.rb

@@ -1,5 +1,3 @@
-require 'windows/error' if ServerEngine.windows?
-
 describe ServerEngine::WinSock do
   # On Ruby 3.0, you need to use fiddle 1.0.8 or later to retrieve a correct
   # error code. In addition, you need to specify the path of fiddle by RUBYLIB
@@ -12,7 +10,8 @@ describe ServerEngine::WinSock do
   context 'last_error' do
     it 'bind error' do
       expect(WinSock.bind(0, nil, 0)).to be -1
-      expect(WinSock.last_error).to be Windows::Error::WSAENOTSOCK
+      WSAENOTSOCK = 10038
+      expect(WinSock.last_error).to be WSAENOTSOCK
     end
   end
 end if ServerEngine.windows?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serverengine
 version: !ruby/object:Gem::Version
-  version: 2.2.5
+  version: 2.3.1
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-13 00:00:00.000000000 Z
+date: 2022-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sigdump
@@ -80,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.4
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: A framework to implement robust multiprocess servers like Unicorn
 email:
 - frsyuki@gmail.com
@@ -154,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: ServerEngine - multiprocess server framework