serverengine 1.5.0

data/lib/serverengine/utils.rb

@@ -0,0 +1,32 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module ServerEngine
+
+  module ClassMethods
+    def dump_uncaught_error(e)
+      STDERR.write "Unexpected error #{e}\n"
+      e.backtrace.each {|bt|
+        STDERR.write "  #{bt}\n"
+      }
+      nil
+    end
+  end
+
+  extend ClassMethods
+
+end

data/lib/serverengine/version.rb

@@ -0,0 +1,3 @@
+module ServerEngine
+  VERSION = "1.5.0"
+end

data/lib/serverengine/worker.rb

@@ -0,0 +1,73 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module ServerEngine
+
+  class Worker
+    def initialize(server, worker_id)
+      @server = server
+      @config = server.config
+      @logger = @server.logger
+      @worker_id = worker_id
+    end
+
+    attr_reader :server, :worker_id
+    attr_accessor :config, :logger
+
+    def before_fork
+    end
+
+    def run
+      raise NoMethodError, "Worker#run method is not implemented"
+    end
+
+    def stop
+    end
+
+    def reload
+    end
+
+    def close
+    end
+
+    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(Daemon::Signals::GRACEFUL_RESTART) { w.stop }
+        st.trap(Daemon::Signals::IMMEDIATE_RESTART, 'SIG_DFL')
+
+        st.trap(Daemon::Signals::RELOAD) {
+          w.logger.reopen!
+          w.reload
+        }
+        st.trap(Daemon::Signals::DETACH) { w.stop }
+
+        st.trap(Daemon::Signals::DUMP) { Sigdump.dump }
+      end
+    end
+
+    def main
+      run
+    ensure
+      close
+    end
+  end
+
+end

data/serverengine.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path 'lib/serverengine/version', File.dirname(__FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "serverengine"
+  gem.version       = ServerEngine::VERSION
+
+  gem.authors       = ["Sadayuki Furuhashi"]
+  gem.email         = ["frsyuki@gmail.com"]
+  gem.description   = %q{A framework to implement robust multiprocess servers like Unicorn}
+  gem.summary       = %q{ServerEngine - multiprocess server framework}
+  gem.homepage      = "https://github.com/frsyuki/serverengine"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.has_rdoc = false
+
+  gem.required_ruby_version = ">= 1.9.3"
+
+  gem.add_dependency("sigdump", ["~> 0.2.2"])
+
+  gem.add_development_dependency("rake", [">= 0.9.2"])
+  gem.add_development_dependency("rspec", ["~> 2.13.0"])
+end

data/spec/blocking_flag_spec.rb

@@ -0,0 +1,58 @@
+
+describe ServerEngine::BlockingFlag do
+  subject { BlockingFlag.new }
+
+  it 'set and reset' do
+    should_not be_set
+    subject.set!
+    should be_set
+    subject.reset!
+    should_not be_set
+  end
+
+  it 'set! and reset! return whether it toggled the state' do
+    subject.reset!.should == false
+    subject.set!.should == true
+    subject.set!.should == false
+    subject.reset!.should == true
+  end
+
+  it 'wait_for_set timeout' do
+    start = Time.now
+
+    subject.wait_for_set(0.01)
+    elapsed = Time.now - start
+
+    elapsed.should >= 0.01
+  end
+
+  it 'wait_for_reset timeout' do
+    subject.set!
+
+    start = Time.now
+
+    subject.wait_for_reset(0.01)
+    elapsed = Time.now - start
+
+    elapsed.should >= 0.01
+  end
+
+  it 'wait' do
+    start = Time.now
+    elapsed = nil
+
+    started = BlockingFlag.new
+    t = Thread.new do
+      started.set!
+      subject.wait_for_set(1)
+      elapsed = Time.now - start
+    end
+    started.wait_for_set
+
+    subject.set!
+    t.join
+
+    elapsed.should_not be_nil
+    elapsed.should < 0.5
+  end
+end

data/spec/daemon_logger_spec.rb

@@ -0,0 +1,88 @@
+
+describe ServerEngine::DaemonLogger do
+  before { FileUtils.mkdir_p("tmp") }
+  before { FileUtils.rm_f("tmp/se1.log") }
+  before { FileUtils.rm_f("tmp/se2.log") }
+
+  subject { DaemonLogger.new("tmp/se1.log", log_stdout: false, log_stderr: false) }
+
+  it 'reopen' do
+    subject.path = 'tmp/se2.log'
+    subject.reopen!
+    subject.warn "test"
+
+    File.read('tmp/se2.log').should =~ /test$/
+  end
+
+  it 'stderr hook 1' do
+    subject.hook_stderr!
+    STDERR.puts "test"
+
+    File.read('tmp/se1.log').should == "test\n"
+  end
+
+  it 'stderr hook 2' do
+    log = DaemonLogger.new("tmp/se1.log", log_stdout: false, log_stderr: true)
+    STDERR.puts "test"
+
+    File.read('tmp/se1.log').should == "test\n"
+  end
+
+  it 'stderr hook and reopen' do
+    subject.hook_stderr!
+    subject.path = 'tmp/se2.log'
+    subject.reopen!
+    STDERR.puts "test"
+
+    File.read('tmp/se2.log').should == "test\n"
+  end
+
+  it 'default level is debug' do
+    subject.debug 'debug'
+    File.read('tmp/se1.log').should =~ /debug$/
+  end
+
+  it 'level set by int' do
+    subject.level = Logger::FATAL
+    subject.level.should == Logger::FATAL
+
+    subject.level = Logger::ERROR
+    subject.level.should == Logger::ERROR
+
+    subject.level = Logger::WARN
+    subject.level.should == Logger::WARN
+
+    subject.level = Logger::INFO
+    subject.level.should == Logger::INFO
+
+    subject.level = Logger::DEBUG
+    subject.level.should == Logger::DEBUG
+  end
+
+  it 'level set by string' do
+    subject.level = 'fatal'
+    subject.level.should == Logger::FATAL
+
+    subject.level = 'error'
+    subject.level.should == Logger::ERROR
+
+    subject.level = 'warn'
+    subject.level.should == Logger::WARN
+
+    subject.level = 'info'
+    subject.level.should == Logger::INFO
+
+    subject.level = 'debug'
+    subject.level.should == Logger::DEBUG
+  end
+
+  it 'unknown level' do
+    lambda { subject.level = 'unknown' }.should raise_error(ArgumentError)
+  end
+
+  it 'stdout logger' do
+    STDOUT.should_not_receive(:reopen)
+    log = DaemonLogger.new(STDOUT)
+    log.debug "stdout logging test"
+  end
+end

data/spec/daemon_spec.rb

@@ -0,0 +1,46 @@
+
+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")
+    dm.main
+
+    test_state(:server_initialize).should == 1
+
+    pid = File.read('tmp/pid').to_i
+    wait_for_fork
+
+    Process.kill(:TERM, pid)
+    wait_for_stop
+
+    test_state(:server_stop_graceful).should == 1
+    test_state(:worker_stop).should == 1
+    test_state(:server_after_run).should == 1
+  end
+
+  it 'signals' do
+    dm = Daemon.new(TestServer, TestWorker, daemonize: true, pid_path: "tmp/pid")
+    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
+
+    Process.kill(:USR1, pid)
+    wait_for_stop
+    test_state(:server_restart_graceful).should == 1
+
+    Process.kill(:HUP, pid)
+    wait_for_stop
+    test_state(:server_restart_immediate).should == 1
+
+    Process.kill(:QUIT, pid)
+    wait_for_stop
+    test_state(:server_stop_immediate).should == 1
+  end
+end
+

data/spec/multi_process_server_spec.rb

@@ -0,0 +1,61 @@
+
+describe ServerEngine::MultiWorkerServer do
+  include_context 'test server and worker'
+
+  [MultiThreadServer, MultiProcessServer].each do |impl_class|
+
+    it 'scale up' do
+      config = {:workers => 2}
+
+      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
+      config = {:workers => 2}
+
+      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
+
+  end
+end
+

data/spec/server_worker_context.rb

@@ -0,0 +1,118 @@
+
+require 'pstore'
+
+def reset_test_state
+  FileUtils.mkdir_p 'tmp'
+  FileUtils.rm_f 'tmp/state.pstore'
+  FileUtils.touch 'tmp/state.pstore'
+end
+
+def incr_test_state(key)
+  ps = PStore.new('tmp/state.pstore')
+  ps.transaction do
+    ps[key] ||= 0
+    ps[key] += 1
+  end
+end
+
+def test_state(key)
+  ps = PStore.new('tmp/state.pstore')
+  ps.transaction do
+    return ps[key] || 0
+  end
+end
+
+shared_context 'test server and worker' do
+  before { reset_test_state }
+
+  def wait_for_fork
+    sleep 0.2
+  end
+
+  def wait_for_stop
+    sleep 0.8
+  end
+
+  def wait_for_restart
+    sleep 1.5
+  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 close
+      incr_test_state :server_close
+    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
+      @stop_flag.wait(5.0)
+      @stop_flag.reset!
+    end
+
+    def stop
+      incr_test_state :worker_stop
+      @stop_flag.set!
+    end
+
+    def reload
+      incr_test_state :worker_reload
+    end
+
+    def close
+      incr_test_state :worker_close
+    end
+  end
+
+end