serverengine 1.5.0

data/lib/serverengine/server.rb

@@ -0,0 +1,103 @@
+#
+# 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 Server
+    include ConfigLoader
+
+    def initialize(worker_module, load_config_proc={}, &block)
+      @worker_module = worker_module
+
+      @stop = false
+
+      super(load_config_proc, &block)
+
+      reload_config
+    end
+
+    def before_run
+    end
+
+    def after_run
+    end
+
+    def stop(stop_graceful)
+      @stop = true
+      nil
+    end
+
+    def close
+    end
+
+    def restart(stop_graceful)
+      reload_config
+      @logger.reopen! if @logger
+      nil
+    end
+
+    def reload
+      reload_config
+      @logger.reopen! if @logger
+      nil
+    end
+
+    def install_signal_handlers
+      s = self
+      SignalThread.new do |st|
+        st.trap(Daemon::Signals::GRACEFUL_STOP) { s.stop(true) }
+        st.trap(Daemon::Signals::IMMEDIATE_STOP) { s.stop(false) }
+        st.trap(Daemon::Signals::GRACEFUL_RESTART) { s.restart(true) }
+        st.trap(Daemon::Signals::IMMEDIATE_RESTART) { s.restart(false) }
+        st.trap(Daemon::Signals::RELOAD) { s.reload }
+        st.trap(Daemon::Signals::DETACH) { s.stop(true) }
+        st.trap(Daemon::Signals::DUMP) { Sigdump.dump }
+      end
+    end
+
+    def main
+      create_logger unless @logger
+
+      before_run
+
+      begin
+        run
+      ensure
+        after_run
+      end
+
+    ensure
+      close
+    end
+
+    module WorkerInitializer
+      def initialize
+      end
+    end
+
+    private
+
+    def create_worker(wid)
+      w = Worker.new(self, wid)
+      w.extend(WorkerInitializer)
+      w.extend(@worker_module)
+      w.instance_eval { initialize }
+      w
+    end
+  end
+
+end

data/lib/serverengine/signal_thread.rb

@@ -0,0 +1,143 @@
+#
+# 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 SignalThread < Thread
+    def initialize(&block)
+      require 'thread'
+
+      @handlers = {}
+
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @queue = []
+      @finished = false
+
+      block.call(self) if block
+
+      super(&method(:main))
+    end
+
+    def trap(sig, command=nil, &block)
+      # normalize signal names
+      sig = sig.to_s.upcase
+      if sig[0,3] == "SIG"
+        sig = sig[3..-1]
+      end
+      sig = sig.to_sym
+
+      old = @handlers[sig]
+      if block
+        Kernel.trap(sig) { enqueue(sig) }
+        @handlers[sig] = block
+      else
+        Kernel.trap(sig, command)
+        @handlers.delete(sig)
+      end
+
+      old
+    end
+
+    def handlers
+      handlers.dup
+    end
+
+    def stop
+      @mutex.synchronize do
+        ## synchronized state 1
+        @finished = true
+        @cond.broadcast
+        ## synchronized state 2
+      end
+      self
+    end
+
+    private
+
+    def main
+      @mutex.lock
+
+      until @finished
+        ## synchronized state 3
+
+        sig = @queue.shift
+        unless sig
+          ## synchronized state 4
+          @cond.wait(@mutex, 1)
+          next
+        end
+
+        ## synchronized state 5
+
+        @mutex.unlock
+        begin
+          @handlers[sig].call(sig)
+        rescue
+          ServerEngine.dump_uncaught_error($!)
+        ensure
+          @mutex.lock
+        end
+      end
+
+      ## synchronized state 6
+      nil
+
+    ensure
+      @mutex.unlock
+      @finished = false
+    end
+
+    def enqueue(sig)
+      @queue << sig
+
+      unless @mutex.try_lock
+        #
+        # here couldn't acquire @mutex.
+        #
+        #   A) a thread is in synchronized state 1 or 2.
+        #      In this case, here doesn't have to broadcast because the thread will/did broadcast.
+        #
+        #   B) `self` thread is in synchronized state 3
+        #      In this case, here doesn't have to broadcast because the `self` thread will
+        #      take a task from the queue soon.
+        #
+        #   C) `self` thread is in synchronized state 4
+        #      In this case, here needs to broadcast but doesn't broadcast. Thus it causes
+        #      blocking upto 1 second :(
+        #
+        #   D) `self` thread is in synchronized state 5
+        #      In this case, here doesn't have to broadcast because the `self` thread will
+        #      change to synchronized state 3 or 6 soon.
+        #
+        #   E) the main thread (the only thread which calls this method) is in synchronized
+        #      state 7. In this case, here doesn't have to broadcast.
+        #
+        return
+      end
+
+      ## synchronized state 7
+
+      begin
+        @cond.broadcast
+      ensure
+        @mutex.unlock
+      end
+    end
+
+  end
+end

data/lib/serverengine/supervisor.rb

@@ -0,0 +1,230 @@
+#
+# 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 Supervisor
+    include ConfigLoader
+
+    def initialize(server_module, worker_module, load_config_proc={}, &block)
+      @server_module = server_module
+      @worker_module = worker_module
+
+      @detach_flag = BlockingFlag.new
+      @stop = false
+
+      @pm = ProcessManager.new(
+        auto_tick: false,
+        graceful_kill_signal: Daemon::Signals::GRACEFUL_STOP,
+        immediate_kill_signal: Daemon::Signals::IMMEDIATE_STOP,
+        auto_heartbeat: true,
+        abort_on_heartbeat_error: false,
+      )
+
+      super(load_config_proc, &block)
+
+      reload_config
+
+      @create_server_proc = Supervisor.create_server_proc(server_module, worker_module, @config)
+      @server_process_name = @config[:server_process_name]
+
+      @restart_server_process = !!@config[:restart_server_process]
+      @enable_detach = !!@config[:enable_detach]
+      @exit_on_detach = !!@config[:exit_on_detach]
+      @disable_reload = !!@config[:disable_reload]
+    end
+
+    def reload_config
+      super
+
+      @server_detach_wait = @config[:server_detach_wait] || 10.0
+      @server_restart_wait = @config[:server_restart_wait] || 1.0
+
+      @pm.configure(@config, prefix: 'server_')
+
+      nil
+    end
+
+    module ServerInitializer
+      def initialize
+        reload_config
+      end
+    end
+
+    def self.create_server_proc(server_module, worker_module, config)
+      wt = config[:worker_type] || 'embedded'
+      case wt
+      when 'embedded'
+        server_class = EmbeddedServer
+      when 'process'
+        server_class = MultiProcessServer
+      when 'thread'
+        server_class = MultiThreadServer
+      else
+        raise ArgumentError, "unexpected :worker_type option #{wt}"
+      end
+
+      lambda {|load_config_proc,logger|
+        s = server_class.new(worker_module, load_config_proc)
+        s.logger = logger
+        s.extend(ServerInitializer)
+        s.extend(server_module) if server_module
+        s.instance_eval { initialize }
+        s
+      }
+    end
+
+    def create_server(logger)
+      @create_server_proc.call(@load_config_proc, logger)
+    end
+
+    def stop(stop_graceful)
+      @stop = true
+      send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_STOP : Daemon::Signals::IMMEDIATE_STOP)
+    end
+
+    def restart(stop_graceful)
+      reload_config
+      @logger.reopen! if @logger
+      if @restart_server_process
+        send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_STOP : Daemon::Signals::IMMEDIATE_STOP)
+      else
+        send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_RESTART : Daemon::Signals::IMMEDIATE_RESTART)
+      end
+    end
+
+    def reload
+      unless @disable_reload
+        reload_config
+      end
+      @logger.reopen! if @logger
+      send_signal(Daemon::Signals::RELOAD)
+    end
+
+    def detach(stop_graceful)
+      if @enable_detach
+        @detach_flag.set!
+        send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_STOP : Daemon::Signals::IMMEDIATE_STOP)
+      else
+        stop(stop_graceful)
+      end
+    end
+
+    def install_signal_handlers
+      s = self
+      SignalThread.new do |st|
+        st.trap(Daemon::Signals::GRACEFUL_STOP) { s.stop(true) }
+        st.trap(Daemon::Signals::IMMEDIATE_STOP) { s.stop(false) }
+        st.trap(Daemon::Signals::GRACEFUL_RESTART) { s.restart(true) }
+        st.trap(Daemon::Signals::IMMEDIATE_RESTART) { s.restart(false) }
+        st.trap(Daemon::Signals::RELOAD) { s.reload }
+        st.trap(Daemon::Signals::DETACH) { s.detach(true) }
+        st.trap(Daemon::Signals::DUMP) { Sigdump.dump }
+      end
+    end
+
+    def main
+      # just in case Supervisor is not created by Daemon
+      create_logger unless @logger
+
+      @pmon = start_server
+
+      while true
+        # keep the child process alive in this loop
+        until @detach_flag.wait(0.5)
+          if stat = try_join
+            return if @stop   # supervisor stoppped explicitly
+
+            # child process died unexpectedly.
+            # sleep @server_detach_wait sec and reboot process
+            @pmon = reboot_server
+          end
+        end
+
+        wait_until = Time.now + @server_detach_wait
+        while (w = wait_until - Time.now) > 0
+          break if try_join
+          sleep [0.5, w].min
+        end
+
+        return if @exit_on_detach
+
+        @detach_flag.reset!
+      end
+    end
+
+    def logger=(logger)
+      super
+      @pm.logger = @logger
+    end
+
+    private
+
+    def send_signal(sig)
+      @pmon.send_signal(sig) if @pmon
+      nil
+    end
+
+    def try_join
+      if stat = @pmon.try_join
+        @logger.info "Server finished#{@stop ? '' : ' unexpectedly'} with #{ProcessManager.format_join_status(stat)}"
+        @pmon = nil
+        return stat
+      else
+        @pm.tick
+        return false
+      end
+    end
+
+    def start_server
+      s = create_server(logger)
+      @last_start_time = Time.now
+
+      begin
+        m = @pm.fork do
+          $0 = @server_process_name if @server_process_name
+          s.install_signal_handlers
+
+          s.main
+        end
+
+        return m
+      ensure
+        s.close
+      end
+    end
+
+    def reboot_server
+      # try reboot for ever until @detach_flag is set
+      while true
+        wait = @server_restart_wait - (Time.now - @last_start_time)
+        if @detach_flag.wait(wait > 0 ? wait : 0.1)
+          break
+        end
+
+        begin
+          return start_server
+        rescue
+          ServerEngine.dump_uncaught_error($!)
+        end
+      end
+
+      return nil
+    end
+  end
+
+end