serverengine 2.0.0pre1-x86-mingw32

data/lib/serverengine/embedded_server.rb

@@ -0,0 +1,67 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+require 'serverengine/server'
+
+module ServerEngine
+
+  class EmbeddedServer < Server
+    def run
+      @worker = create_worker(0)
+      until @stop
+        @worker.main
+      end
+    end
+
+    def stop(stop_graceful)
+      super
+      Thread.new do
+        begin
+          @worker.stop
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+      nil
+    end
+
+    def restart(stop_graceful)
+      super
+      Thread.new do
+        begin
+          @worker.stop
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+      nil
+    end
+
+    def reload
+      super
+      Thread.new do
+        begin
+          @worker.reload
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+      nil
+    end
+  end
+
+end

data/lib/serverengine/multi_process_server.rb

@@ -0,0 +1,155 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+require 'serverengine/signals'
+require 'serverengine/daemon'
+require 'serverengine/process_manager'
+require 'serverengine/multi_worker_server'
+require 'serverengine/privilege'
+
+module ServerEngine
+
+  class MultiProcessServer < MultiWorkerServer
+    def initialize(worker_module, load_config_proc={}, &block)
+      @pm = ProcessManager.new(
+        auto_tick: false,
+        graceful_kill_signal: Signals::GRACEFUL_STOP,
+        immediate_kill_signal: Signals::IMMEDIATE_STOP,
+        enable_heartbeat: true,
+        auto_heartbeat: true,
+        on_heartbeat_error: Proc.new do
+          @logger.fatal "parent process unexpectedly terminated"
+          exit 1
+        end
+      )
+
+      super(worker_module, load_config_proc, &block)
+
+      @worker_process_name = @config[:worker_process_name]
+      @unrecoverable_exit_codes = @config.fetch(:unrecoverable_exit_codes, [])
+    end
+
+    def run
+      super
+    ensure
+      @pm.close
+    end
+
+    def logger=(logger)
+      super
+      @pm.logger = logger
+    end
+
+    private
+
+    def reload_config
+      super
+
+      @chuser = @config[:worker_chuser]
+      @chgroup = @config[:worker_chgroup]
+      @chumask = @config[:worker_chumask]
+
+      @pm.configure(@config, prefix: 'worker_')
+
+      nil
+    end
+
+    def start_worker(wid)
+      w = create_worker(wid)
+
+      w.before_fork
+      begin
+        pmon = @pm.fork do |t|
+          $0 = @worker_process_name % [wid] if @worker_process_name
+          w.install_signal_handlers
+
+          Privilege.change(@chuser, @chgroup)
+          File.umask(@chumask) if @chumask
+
+          ## recreate the logger created at Server#main
+          #create_logger
+
+          w.main
+        end
+
+      ensure
+        w.after_start
+      end
+
+      return WorkerMonitor.new(w, wid, pmon, unrecoverable_exit_codes: @unrecoverable_exit_codes)
+    end
+
+    def wait_tick
+      @pm.tick(0.5)
+    end
+
+    class WorkerMonitor
+      def initialize(worker, wid, pmon, reload_signal = Signals::RELOAD, unrecoverable_exit_codes: [])
+        @worker = worker
+        @wid = wid
+        @pmon = pmon
+        @reload_signal = reload_signal
+        @unrecoverable_exit_codes = unrecoverable_exit_codes
+        @unrecoverable_exit = false
+        @exitstatus = nil
+      end
+
+      attr_reader :exitstatus
+
+      def send_stop(stop_graceful)
+        @stop = true
+        if stop_graceful
+          @pmon.start_graceful_stop! if @pmon
+        else
+          @pmon.start_immediate_stop! if @pmon
+        end
+        nil
+      end
+
+      def send_reload
+        @pmon.send_signal(@reload_signal) if @pmon
+        nil
+      end
+
+      def join
+        @pmon.join if @pmon
+        nil
+      end
+
+      def alive?
+        return false unless @pmon
+
+        if stat = @pmon.try_join
+          @worker.logger.info "Worker #{@wid} finished#{@stop ? '' : ' unexpectedly'} with #{ServerEngine.format_join_status(stat)}"
+          if stat.is_a?(Process::Status) && stat.exited? && @unrecoverable_exit_codes.include?(stat.exitstatus)
+            @unrecoverable_exit = true
+            @exitstatus = stat.exitstatus
+          end
+          @pmon = nil
+          return false
+        else
+          return true
+        end
+      end
+
+      def recoverable?
+        !@unrecoverable_exit
+      end
+    end
+  end
+
+end

data/lib/serverengine/multi_spawn_server.rb

@@ -0,0 +1,95 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+require 'serverengine/signals'
+require 'serverengine/process_manager'
+require 'serverengine/multi_worker_server'
+
+module ServerEngine
+
+  class MultiSpawnServer < MultiWorkerServer
+    def initialize(worker_module, load_config_proc={}, &block)
+      if ServerEngine.windows?
+        @pm = ProcessManager.new(
+          auto_tick: false,
+          graceful_kill_signal: Signals::GRACEFUL_STOP,
+          immediate_kill_signal: false,
+          enable_heartbeat: false,
+        )
+      else
+        @pm = ProcessManager.new(
+          auto_tick: false,
+          graceful_kill_signal: Signals::GRACEFUL_STOP,
+          immediate_kill_signal: Signals::IMMEDIATE_STOP,
+          enable_heartbeat: false,
+        )
+      end
+
+      super(worker_module, load_config_proc, &block)
+
+      @reload_signal = @config[:worker_reload_signal]
+      @unrecoverable_exit_codes = @config.fetch(:unrecoverable_exit_codes, [])
+      @pm.command_sender = @command_sender
+    end
+
+    def stop(stop_graceful)
+      if @command_sender == "pipe"
+        @pm.command_sender_pipe.write(stop_graceful ? "GRACEFUL_STOP\n" : "IMMEDIATE_STOP\n")
+      end
+      super
+    end
+
+    def run
+      super
+    ensure
+      @pm.close
+    end
+
+    def logger=(logger)
+      super
+      @pm.logger = logger
+    end
+
+    private
+
+    def reload_config
+      super
+
+      @pm.configure(@config, prefix: 'worker_')
+
+      nil
+    end
+
+    def start_worker(wid)
+      w = create_worker(wid)
+
+      w.before_fork
+      begin
+        pmon = w.spawn(@pm)
+      ensure
+        w.after_start
+      end
+
+      return MultiProcessServer::WorkerMonitor.new(w, wid, pmon, @reload_signal, unrecoverable_exit_codes: @unrecoverable_exit_codes)
+    end
+
+    def wait_tick
+      @pm.tick(0.5)
+    end
+  end
+
+end

data/lib/serverengine/multi_thread_server.rb

@@ -0,0 +1,80 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+require 'serverengine/multi_worker_server'
+
+module ServerEngine
+
+  class MultiThreadServer < MultiWorkerServer
+    private
+
+    def start_worker(wid)
+      w = create_worker(wid)
+
+      w.before_fork
+      begin
+        thread = Thread.new(&w.method(:main))
+      ensure
+        w.after_start
+      end
+
+      return WorkerMonitor.new(w, thread)
+    end
+
+    class WorkerMonitor
+      def initialize(worker, thread)
+        @worker = worker
+        @thread = thread
+      end
+
+      def send_stop(stop_graceful)
+        Thread.new do
+          begin
+            @worker.stop
+          rescue => e
+            ServerEngine.dump_uncaught_error(e)
+          end
+        end
+        nil
+      end
+
+      def send_reload
+        Thread.new do
+          begin
+            @worker.reload
+          rescue => e
+            ServerEngine.dump_uncaught_error(e)
+          end
+        end
+        nil
+      end
+
+      def join
+        @thread.join
+      end
+
+      def alive?
+        @thread.alive?
+      end
+
+      def recoverable?
+        true
+      end
+    end
+  end
+
+end

data/lib/serverengine/multi_worker_server.rb

@@ -0,0 +1,150 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+require 'serverengine/server'
+
+module ServerEngine
+
+  class MultiWorkerServer < Server
+    def initialize(worker_module, load_config_proc={}, &block)
+      @monitors = []
+      @last_start_worker_time = 0
+
+      super(worker_module, load_config_proc, &block)
+
+      @stop_immediately_at_unrecoverable_exit = @config.fetch(:stop_immediately_at_unrecoverable_exit, false)
+    end
+
+    def stop(stop_graceful)
+      super
+      @monitors.each do |m|
+        m.send_stop(stop_graceful) if m
+      end
+      nil
+    end
+
+    def restart(stop_graceful)
+      super
+      @monitors.each do |m|
+        m.send_stop(stop_graceful) if m
+      end
+      nil
+    end
+
+    def reload
+      super
+      @monitors.each_with_index do |m|
+        m.send_reload if m
+      end
+      nil
+    end
+
+    def run
+      while true
+        num_alive = keepalive_workers
+        break if num_alive == 0
+        wait_tick
+      end
+    end
+
+    def scale_workers(n)
+      @num_workers = n
+
+      plus = n - @monitors.size
+      if plus > 0
+        @monitors.concat Array.new(plus, nil)
+      end
+
+      nil
+    end
+
+    def join_workers
+      @monitors.each {|m|
+        m.join if m
+      }
+    end
+
+    private
+
+    def reload_config
+      super
+
+      @start_worker_delay = @config[:start_worker_delay] || 0
+      @start_worker_delay_rand = @config[:start_worker_delay_rand] || 0.2
+
+      scale_workers(@config[:workers] || 1)
+
+      nil
+    end
+
+    def wait_tick
+      sleep 0.5
+    end
+
+    def keepalive_workers
+      num_alive = 0
+
+      @monitors.each_with_index do |m,wid|
+        if m && m.alive?
+          # alive
+          num_alive += 1
+
+        elsif m && m.respond_to?(:recoverable?) && !m.recoverable?
+          # exited, with unrecoverable exit code
+          if @stop_immediately_at_unrecoverable_exit
+            stop(true) # graceful stop for workers
+            # @stop is set by Server#stop
+          end
+          # server will stop when all workers exited in this state
+          # the last status will be used for server/supervisor/daemon
+          @stop_status = m.exitstatus if m.exitstatus
+
+        elsif wid < @num_workers
+          # scale up or reboot
+          unless @stop
+            @monitors[wid] = delayed_start_worker(wid)
+            num_alive += 1
+          end
+
+        elsif m
+          # scale down
+          @monitors[wid] = nil
+        end
+      end
+
+      return num_alive
+    end
+
+    def delayed_start_worker(wid)
+      if @start_worker_delay > 0
+        delay = @start_worker_delay +
+          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)
+        sleep wait if wait > 0
+
+        @last_start_worker_time = now
+      end
+
+      start_worker(wid)
+    end
+  end
+
+end