serverengine 2.0.0pre1-x64-mingw32

data/spec/signal_thread_spec.rb

@@ -0,0 +1,94 @@
+
+describe ServerEngine::SignalThread do
+  it 'start and stop' do
+    t = SignalThread.new
+    t.stop.should == t
+    t.join
+  end
+
+  unless ServerEngine.windows?
+    it 'call handler' do
+      n = 0
+
+      t = SignalThread.new do |st|
+        st.trap('CONT') { n += 1 }
+      end
+
+      Process.kill('CONT', Process.pid)
+      sleep 0.5
+
+      t.stop.join
+
+      n.should == 1
+    end
+
+    it 'SIG_IGN' do
+      # IGNORE signal handler has possible race condition in Ruby 2.1
+      # https://bugs.ruby-lang.org/issues/9835
+      # That's why ignore this test in Ruby2.1
+      if RUBY_VERSION >= '2.2'
+        t = SignalThread.new do |st|
+          st.trap('QUIT', 'SIG_IGN')
+        end
+
+        Process.kill('QUIT', Process.pid)
+
+        t.stop.join
+      end
+    end
+
+    it 'signal in handler' do
+      n = 0
+
+      SignalThread.new do |st|
+        st.trap('QUIT') do
+          if n < 3
+            Process.kill('QUIT', Process.pid)
+            n += 1
+          end
+        end
+      end
+
+      Process.kill('QUIT', Process.pid)
+      sleep 0.5
+
+      n.should == 3
+    end
+
+    it 'stop in handler' do
+      t = SignalThread.new do |st|
+        st.trap('QUIT') { st.stop }
+      end
+
+      Process.kill('QUIT', Process.pid)
+      sleep 0.5
+
+      t.join
+    end
+
+    it 'should not deadlock' do
+      n = 0
+
+      SignalThread.new do |st|
+        st.trap('CONT') { n += 1 }
+      end
+
+      (1..10).map {
+        Thread.new do
+          10.times {
+            Process.kill('CONT', Process.pid)
+          }
+        end
+      }.each { |t|
+        t.join
+      }
+
+      # give chance to run the signal thread
+      sleep 0.1
+
+      # result won't be 100 because of kernel limitation
+      n.should > 0
+    end
+  end
+end
+

data/spec/socket_manager_spec.rb

@@ -0,0 +1,119 @@
+
+describe ServerEngine::SocketManager do
+  include_context 'test server and worker'
+
+  let(:server_path) do
+    'tmp/socket_manager_test.sock'
+  end
+
+  after(:each) do
+    File.unlink(server_path) if File.exist?(server_path)
+  end
+
+  if ServerEngine.windows?
+    let(:server_port) do
+     24223
+    end
+
+    let(:test_port) do
+      9101
+    end
+
+    it 'is windows' do
+      SocketManager::Client.is_a?(SocketManagerWin::ClientModule)
+      SocketManager::Server.is_a?(SocketManagerWin::ServerModule)
+    end
+
+    context 'with thread' do
+      it 'works' do
+        server = SocketManager::Server.open(server_port)
+
+        thread = Thread.new do
+
+          client = ServerEngine::SocketManager::Client.new(server_port)
+          tcp = client.listen_tcp('127.0.0.1', test_port)
+          udp = client.listen_udp('127.0.0.1', test_port)
+
+          incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
+          incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+
+          data, _from = udp.recvfrom(10)
+          incr_test_state(:udp_data_sent) if data == "ok"
+
+          s = tcp.accept
+          s.write("ok")
+          s.close
+        end
+
+        sleep 1
+
+        u = UDPSocket.new
+        u.send "ok", 0, '127.0.0.1', test_port
+        u.close
+
+        t = TCPSocket.open('127.0.0.1', test_port)
+        t.read.should == "ok"
+        t.close
+
+        server.close
+        thread.join
+
+        test_state(:is_tcp_server).should == 1
+        test_state(:is_udp_socket).should == 1
+        test_state(:udp_data_sent).should == 1
+      end
+    end
+
+  else
+    let(:test_port) do
+      9102
+    end
+
+    it 'is unix' do
+      SocketManager::Client.is_a?(SocketManagerUnix::ClientModule)
+      SocketManager::Server.is_a?(SocketManagerUnix::ServerModule)
+    end
+
+    context 'with fork' do
+      it 'works' do
+        server = SocketManager::Server.open(server_path)
+
+        fork do
+          server.close
+
+          client = server.new_client
+
+          tcp = client.listen_tcp('127.0.0.1', test_port)
+          udp = client.listen_udp('127.0.0.1', test_port)
+
+          incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
+          incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+
+          data, _from = udp.recvfrom(10)
+          incr_test_state(:udp_data_sent) if data == "ok"
+
+          s = tcp.accept
+          s.write("ok")
+          s.close
+        end
+
+        wait_for_fork
+
+        u = UDPSocket.new
+        u.send "ok", 0, '127.0.0.1', test_port
+        u.close
+
+        t = TCPSocket.open('127.0.0.1', test_port)
+        t.read.should == "ok"
+        t.close
+
+        server.close
+
+        test_state(:is_tcp_server).should == 1
+        test_state(:is_udp_socket).should == 1
+        test_state(:udp_data_sent).should == 1
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'serverengine'
+include ServerEngine
+
+# require sigdump only in unix, because there is no suport for SIGCONT in windows.
+unless ServerEngine.windows?
+  require 'sigdump/setup'
+end
+require 'server_worker_context'
+

data/spec/supervisor_spec.rb

@@ -0,0 +1,215 @@
+
+describe ServerEngine::Supervisor do
+  include_context 'test server and worker'
+
+  def start_supervisor(worker = nil, **config)
+    if ServerEngine.windows?
+      config[:windows_daemon_cmdline] = windows_supervisor_cmdline(nil, worker, config)
+    end
+    sv = Supervisor.new(TestServer, worker || TestWorker, config)
+    t = Thread.new { sv.main }
+
+    return sv, t
+  end
+
+  def start_daemon(**config)
+    if ServerEngine.windows?
+      config[:windows_daemon_cmdline] = windows_daemon_cmdline
+    end
+    daemon = Daemon.new(nil, TestWorker, config)
+    t = Thread.new { daemon.main }
+
+    return daemon, t
+  end
+
+  context 'when :log=IO option is given' do
+    it 'can start' do
+      daemon, t = start_daemon(log: STDOUT)
+
+      begin
+        wait_for_fork
+      ensure
+        daemon.server.stop(true)
+        t.join
+      end
+
+      test_state(:worker_run).should == 1
+      daemon.server.logger.should be_an_instance_of(ServerEngine::DaemonLogger)
+    end
+  end
+
+  context 'when :logger option is given' do
+    it 'uses specified logger instance' do
+      logger = ServerEngine::DaemonLogger.new(STDOUT)
+      daemon, t = start_daemon(logger: logger)
+
+      begin
+        wait_for_fork
+      ensure
+        daemon.server.stop(true)
+        t.join
+      end
+
+      test_state(:worker_run).should == 1
+      daemon.server.logger.should == logger
+    end
+  end
+
+  context 'when both :logger and :log options are given' do
+    it 'start ignoring :log' do
+      logger = ServerEngine::DaemonLogger.new(STDOUT)
+      daemon, t = start_daemon(logger: logger, log: STDERR)
+
+      begin
+        wait_for_fork
+      ensure
+        daemon.server.stop(true)
+        t.join
+      end
+
+      test_state(:worker_run).should == 1
+      daemon.server.logger.should == logger
+    end
+  end
+
+  ['signal', 'pipe'].each do |sender|
+    context "when using #{sender} as command_sender" do
+
+      it 'start and graceful stop' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(command_sender: sender)
+
+        begin
+          wait_for_fork
+
+          test_state(:server_before_run).should == 1
+          test_state(:server_after_start).should == 1  # parent
+        ensure
+          sv.stop(true)
+          t.join
+        end
+
+        test_state(:server_stop).should == 1
+        test_state(:server_stop_graceful).should == 1
+        test_state(:server_restart).should == 0
+
+        test_state(:server_after_run).should == 1
+        test_state(:server_after_start).should == 1
+      end
+
+      it 'immediate stop' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(command_sender: sender)
+
+        begin
+          wait_for_fork
+        ensure
+          sv.stop(false)
+          t.join
+        end
+
+        test_state(:server_stop).should == 1
+        test_state(:server_stop_immediate).should == 1
+        test_state(:server_after_run).should == 1
+        test_state(:server_after_start).should == 1
+      end
+
+      it 'graceful restart' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(command_sender: sender)
+
+        begin
+          wait_for_fork
+
+          sv.restart(true)
+          wait_for_stop
+
+        ensure
+          sv.stop(true)
+          t.join
+        end
+
+        test_state(:server_stop).should == 1
+        test_state(:server_restart_graceful).should == 1
+
+        test_state(:server_before_run).should == 1
+        test_state(:server_after_run).should == 1
+        test_state(:server_after_start).should == 1
+      end
+
+      it 'immediate restart' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(command_sender: sender)
+
+        begin
+          wait_for_fork
+
+          sv.restart(false)
+          wait_for_stop
+
+        ensure
+          sv.stop(true)
+          t.join
+        end
+
+        test_state(:server_stop).should == 1
+        test_state(:server_restart_immediate).should == 1
+
+        test_state(:server_before_run).should == 1
+        test_state(:server_after_run).should == 1
+        test_state(:server_after_start).should == 1
+      end
+
+      it 'reload' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(command_sender: sender)
+
+        begin
+          wait_for_fork
+
+          sv.reload
+
+        ensure
+          sv.stop(true)
+          t.join
+        end
+
+        test_state(:server_stop).should == 1
+        test_state(:server_reload).should == 1
+      end
+
+      # TODO detach
+
+      it 'auto restart in limited ratio' do
+        pending 'not supported on Windows' if ServerEngine.windows? && sender == 'signal'
+
+        sv, t = start_supervisor(RunErrorWorker, server_restart_wait: 1, command_sender: sender)
+
+        begin
+          sleep 2.2
+        ensure
+          sv.stop(true)
+          t.join
+        end
+
+        test_state(:worker_run).should == 3
+      end
+    end
+  end
+
+  module InitializeErrorServer
+    def initialize
+      raise StandardError, "error test"
+    end
+  end
+
+  it 'initialize error' do
+    sv = Supervisor.new(InitializeErrorServer, TestWorker)
+    lambda { sv.main }.should raise_error(StandardError)
+  end
+end