serverengine 1.6.4 → 2.0.0pre1

data/lib/serverengine/utils.rb

@@ -32,6 +32,29 @@ module ServerEngine
       }
       nil
     end
+
+    def format_signal_name(n)
+      Signal.list.each_pair {|k,v|
+        return "SIG#{k}" if n == v
+      }
+      return n
+    end
+
+    def format_join_status(code)
+      case code
+      when Process::Status
+        if code.signaled?
+          "signal #{format_signal_name(code.termsig)}"
+        else
+          "status #{code.exitstatus}"
+        end
+      when Exception
+        "exception #{code}"
+      when nil
+        "unknown reason"
+      end
+    end
+
   end
 
   extend ClassMethods

data/lib/serverengine/version.rb

@@ -1,3 +1,3 @@
 module ServerEngine
-  VERSION = "1.6.4"
+  VERSION = "2.0.0pre1"
 end

data/lib/serverengine/worker.rb

@@ -15,6 +15,9 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/signals'
+require 'serverengine/signal_thread'
+
 module ServerEngine
 
   class Worker
@@ -54,19 +57,19 @@ module ServerEngine
     def install_signal_handlers
       w = self
       SignalThread.new do |st|
-        st.trap(Daemon::Signals::GRACEFUL_STOP) { w.stop }
-        st.trap(Daemon::Signals::IMMEDIATE_STOP, 'SIG_DFL')
+        st.trap(Signals::GRACEFUL_STOP) { w.stop }
+        st.trap(Signals::IMMEDIATE_STOP, 'SIG_DFL')
 
-        st.trap(Daemon::Signals::GRACEFUL_RESTART) { w.stop }
-        st.trap(Daemon::Signals::IMMEDIATE_RESTART, 'SIG_DFL')
+        st.trap(Signals::GRACEFUL_RESTART) { w.stop }
+        st.trap(Signals::IMMEDIATE_RESTART, 'SIG_DFL')
 
-        st.trap(Daemon::Signals::RELOAD) {
+        st.trap(Signals::RELOAD) {
           w.logger.reopen!
           w.reload
         }
-        st.trap(Daemon::Signals::DETACH) { w.stop }
+        st.trap(Signals::DETACH) { w.stop }
 
-        st.trap(Daemon::Signals::DUMP) { Sigdump.dump }
+        st.trap(Signals::DUMP) { Sigdump.dump }
       end
     end
 

data/lib/serverengine.rb

@@ -19,34 +19,15 @@ module ServerEngine
 
   require 'sigdump'
 
-  here = File.expand_path(File.dirname(__FILE__))
+  require 'serverengine/version'
 
-  {
-    :BlockingFlag => 'serverengine/blocking_flag',
-    :SignalThread => 'serverengine/signal_thread',
-    :DaemonLogger => 'serverengine/daemon_logger',
-    :ConfigLoader => 'serverengine/config_loader',
-    :Daemon => 'serverengine/daemon',
-    :Supervisor => 'serverengine/supervisor',
-    :Server => 'serverengine/server',
-    :EmbeddedServer => 'serverengine/embedded_server',
-    :MultiWorkerServer => 'serverengine/multi_worker_server',
-    :MultiProcessServer => 'serverengine/multi_process_server',
-    :MultiThreadServer => 'serverengine/multi_thread_server',
-    :MultiSpawnServer => 'serverengine/multi_spawn_server',
-    :ProcessManager => 'serverengine/process_manager',
-    :SocketManager => 'serverengine/socket_manager',
-    :Worker => 'serverengine/worker',
-    :VERSION => 'serverengine/version',
-  }.each_pair {|k,v|
-    autoload k, File.expand_path(v, File.dirname(__FILE__))
-  }
+  require 'serverengine/utils' # ServerEngine.windows? and other util methods
 
-  [
-    'serverengine/utils',
-  ].each {|v|
-    require File.join(here, v)
-  }
+  require 'serverengine/daemon'
+  require 'serverengine/supervisor'
+  require 'serverengine/server'
+  require 'serverengine/worker'
+  require 'serverengine/socket_manager'
 
   def self.create(server_module, worker_module, load_config_proc={}, &block)
     Daemon.new(server_module, worker_module, load_config_proc, &block)
@@ -54,8 +35,9 @@ module ServerEngine
 
   def self.ruby_bin_path
     if ServerEngine.windows?
+      require 'windows/library'
       ruby_path = "\0" * 256
-      GetModuleFileName.call(0, ruby_path, 256)
+      Windows::Library::GetModuleFileName.call(0, ruby_path, 256)
       return ruby_path.rstrip.gsub(/\\/, '/')
     else
       return File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["RUBY_INSTALL_NAME"]) + RbConfig::CONFIG["EXEEXT"]

data/serverengine.gemspec

@@ -17,10 +17,21 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.has_rdoc = false
 
-  gem.required_ruby_version = ">= 1.9.3"
+  gem.required_ruby_version = ">= 2.1.0"
 
   gem.add_dependency "sigdump", ["~> 0.2.2"]
 
   gem.add_development_dependency "rake", [">= 0.9.2"]
   gem.add_development_dependency "rspec", ["~> 2.13.0"]
+
+  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
 end

data/spec/daemon_logger_spec.rb

@@ -1,10 +1,12 @@
 require 'stringio'
 
 describe ServerEngine::DaemonLogger do
+  before { FileUtils.rm_rf("tmp") }
   before { FileUtils.mkdir_p("tmp") }
   before { FileUtils.rm_f("tmp/se1.log") }
-  before { FileUtils.rm_f Dir["tmp/se1.log.**"] }
   before { FileUtils.rm_f("tmp/se2.log") }
+  before { FileUtils.rm_f Dir["tmp/se3.log.**"] }
+  before { FileUtils.rm_f Dir["tmp/se4.log.**"] }
 
   subject { DaemonLogger.new("tmp/se1.log", level: 'trace') }
 
@@ -113,26 +115,27 @@ describe ServerEngine::DaemonLogger do
   end
 
   it 'rotation' do
-    log = DaemonLogger.new("tmp/se1.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10000)
+    log = DaemonLogger.new("tmp/se3.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10000)
     # 100 bytes
     log.warn "test1"*20
-    File.exist?("tmp/se1.log").should == true
-    File.exist?("tmp/se1.log.0").should == false
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.0").should == false
 
     # 10000 bytes
     100.times { log.warn "test2"*20 }
-    File.exist?("tmp/se1.log").should == true
-    File.exist?("tmp/se1.log.0").should == true
-    File.read("tmp/se1.log.0") =~ /test2$/
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.0").should == true
+    File.read("tmp/se3.log.0") =~ /test2$/
 
     # 10000 bytes
     100.times { log.warn "test3"*20 }
-    File.exist?("tmp/se1.log").should == true
-    File.exist?("tmp/se1.log.1").should == true
-    File.exist?("tmp/se1.log.2").should == false
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.1").should == true
+    File.exist?("tmp/se3.log.2").should == false
 
     log.warn "test4"*20
-    File.read("tmp/se1.log.0") =~ /test5$/
+    File.read("tmp/se3.log").should =~ /test4$/
+    File.read("tmp/se3.log.0").should =~ /test3$/
   end
 
   it 'IO logger' do
@@ -146,7 +149,9 @@ describe ServerEngine::DaemonLogger do
   end
 
   it 'inter-process locking on rotation' do
-    log = DaemonLogger.new("tmp/se1.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10)
+    pending "fork is not implemented in Windows" if ServerEngine.windows?
+
+    log = DaemonLogger.new("tmp/se4.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10)
     r, w = IO.pipe
     $stderr = w # To capture #warn output in DaemonLogger
     pid1 = Process.fork do

data/spec/daemon_spec.rb

@@ -2,45 +2,168 @@
 describe ServerEngine::Daemon do
   include_context 'test server and worker'
 
-  it 'run and graceful stop' do
-    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid")
+  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
 
-    pid = File.read('tmp/pid').to_i
+    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
 
-    Process.kill(:TERM, pid)
-    wait_for_stop
+    begin
+      dm.reload
+      wait_for_stop
+      test_state(:server_reload).should == 1
 
-    test_state(:server_stop_graceful).should == 1
-    test_state(:worker_stop).should == 1
-    test_state(:server_after_run).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 'signals' do
-    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid")
+  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
 
-    pid = File.read('tmp/pid').to_i
     wait_for_fork
 
-    Process.kill(:USR2, pid)
-    wait_for_stop
-    test_state(:server_reload).should == 1
+    begin
+      dm.reload
+      wait_for_stop
+      test_state(:server_reload).should == 1
 
-    Process.kill(:USR1, pid)
-    wait_for_stop
-    test_state(:server_restart_graceful).should == 1
+      dm.restart(true)
+      wait_for_stop
+      test_state(:server_restart_graceful).should == 1
 
-    Process.kill(:HUP, pid)
-    wait_for_stop
-    test_state(:server_restart_immediate).should == 1
+      dm.restart(false)
+      wait_for_stop
+      test_state(:server_restart_immediate).should == 1
 
-    Process.kill(:QUIT, pid)
-    wait_for_stop
-    test_state(:server_stop_immediate).should == 1
+      dm.stop(false)
+      wait_for_stop
+      test_state(:server_stop_immediate).should == 1
+    ensure
+      dm.stop(true) rescue nil
+    end
   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

@@ -1,11 +1,13 @@
+[ServerEngine::MultiThreadServer, ServerEngine::MultiProcessServer].each do |impl_class|
+  # MultiProcessServer uses fork(2) internally, then it doesn't support Windows.
 
-describe ServerEngine::MultiWorkerServer do
-  include_context 'test server and worker'
-
-  [MultiThreadServer, MultiProcessServer].each do |impl_class|
+  describe impl_class do
+    include_context 'test server and worker'
 
     it 'scale up' do
-      config = {:workers => 2}
+      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 }
@@ -31,7 +33,9 @@ describe ServerEngine::MultiWorkerServer do
     end
 
     it 'scale down' do
-      config = {:workers => 2}
+      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 }
@@ -56,6 +60,54 @@ describe ServerEngine::MultiWorkerServer do
       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

@@ -7,6 +7,76 @@ def reset_test_state
   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)
@@ -20,6 +90,7 @@ def incr_test_state(key)
 
       f.pos = 0
       f.write YAML.dump(data)
+      data[key]
     end
   end
 end
@@ -111,6 +182,39 @@ module TestWorker
   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 }