serverengine 2.2.5 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2175217415cd5751a1bd4a8d60c5abdb64e80429e722c41e8c1e97ec02b1e22a
-  data.tar.gz: 63a7af53a0dc906bb962394f902d1486f7958950c9b3b9bf41206e56789d83ad
+  metadata.gz: b1c09d476bdc08a078882ba14ee74f487ab988a397d2228c3e83f611fff94df1
+  data.tar.gz: 33732af3d1c591ec28c67249b1b67b16b142f80048f70c3cf5c769b3e267b76a
 SHA512:
-  metadata.gz: 85880cc1ec9b83e03b2cbe80756253e156e46954117ae0a008388bfccf3d412b96a54911f9f002b6387ec2dfa9ef35dd3a40bff1dff22f7b5ca180f667d88611
-  data.tar.gz: 624a1e6397faa39af9b871ef91571b432263d6b2b595fc4bdfaa9244a6153b25a67fe80c38c6f814c94db27b0dddcc1e4e19ae08515c8e48c2ee6208478775d0
+  metadata.gz: 383aaf8822f01aec3ce2e4a25243da8ca741da9d11f97c601c31cc6985e285743a088cafdd4fd918b58a966960376f65b28645b1fca74d0741e64052bd329ac8
+  data.tar.gz: ca10bd75948760060c8ae433cb2021a7024d6b076d84157012db5ae6809d01c9a8bb2eb2bb1f9f8d84f0881e4cbaf3bebfb25ef959130574e0cf717550ee1867

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,3 +1,15 @@
+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

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

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.0"
 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,5 @@ 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"]
 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/multi_spawn_server_spec.rb

@@ -1,25 +1,208 @@
 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}
+  describe 'starts worker processes' do
+    context 'with command_sender=pipe' do
+      it do
+        config = {workers: 2, command_sender: 'pipe', log_stdout: false, log_stderr: false}
 
-      s = ServerEngine::MultiSpawnServer.new(TestWorker) { config.dup }
-      t = Thread.new { s.main }
+        s = ServerEngine::MultiSpawnServer.new(TestWorker) { config.dup }
+        t = Thread.new { s.main }
 
-      begin
-        wait_for_fork
+        begin
+          wait_for_fork
 
-        Timeout.timeout(5) do
-          sleep(0.5) until test_state(:worker_run) == 2
+          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',
+        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
+
+          Timecop.freeze(Time.now + restart_worker_interval - mergin_time)
+          sleep(1.5)
+          monitors.count { |m| m.alive? }.should == 0
+
+          Timecop.travel(Time.now + 2 * mergin_time)
+          sleep(1.5)
+          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
-        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/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.0
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-13 00:00:00.000000000 Z
+date: 2022-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sigdump
@@ -80,6 +80,20 @@ 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
 description: A framework to implement robust multiprocess servers like Unicorn
 email:
 - frsyuki@gmail.com
@@ -154,7 +168,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