serverengine 1.6.4 → 2.0.0pre1

data/lib/serverengine/privilege.rb

@@ -0,0 +1,57 @@
+#
+# 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.
+#
+require 'etc'
+
+module ServerEngine
+  module Privilege
+    def self.get_etc_passwd(user)
+      if user.to_i.to_s == user
+        Etc.getpwuid(user.to_i)
+      else
+        Etc.getpwnam(user)
+      end
+    end
+
+    def self.get_etc_group(group)
+      if group.to_i.to_s == group
+        Etc.getgrgid(group.to_i)
+      else
+        Etc.getgrnam(group)
+      end
+    end
+
+    def self.change(user, group)
+      if user
+        etc_pw = get_etc_passwd(user)
+        user_groups = [etc_pw.gid]
+        Etc.setgrent
+        Etc.group { |gr| user_groups << gr.gid if gr.mem.include?(etc_pw.name) } # emulate 'id -G'
+
+        Process.groups = Process.groups | user_groups
+        Process::UID.change_privilege(etc_pw.uid)
+      end
+
+      if group
+        etc_group = get_etc_group(group)
+        Process::GID.change_privilege(etc_group.gid)
+      end
+
+      nil
+    end
+  end
+end

data/lib/serverengine/process_manager.rb

@@ -15,9 +15,9 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-module ServerEngine
+require 'fcntl'
 
-  require 'fcntl'
+module ServerEngine
 
   class ProcessManager
     def initialize(config={})
@@ -57,7 +57,7 @@ module ServerEngine
       @read_buffer = ''
 
       if @auto_tick
-        TickThread.new(self)
+        TickThread.new(@auto_tick_interval, &method(:tick))
       end
     end
 
@@ -69,6 +69,9 @@ module ServerEngine
     attr_reader :auto_tick, :auto_tick_interval
     attr_reader :enable_heartbeat, :auto_heartbeat
 
+    attr_accessor :command_sender
+    attr_reader :command_sender_pipe
+
     CONFIG_PARAMS = {
       heartbeat_interval: 1,
       heartbeat_timeout: 180,
@@ -96,6 +99,21 @@ module ServerEngine
       }
     end
 
+    def monitor_options
+      {
+        enable_heartbeat: @enable_heartbeat,
+        heartbeat_timeout: @heartbeat_timeout,
+        graceful_kill_signal: @graceful_kill_signal,
+        graceful_kill_timeout: @graceful_kill_timeout,
+        graceful_kill_interval: @graceful_kill_interval,
+        graceful_kill_interval_increment: @graceful_kill_interval_increment,
+        immediate_kill_signal: @immediate_kill_signal,
+        immediate_kill_timeout: @immediate_kill_timeout,
+        immediate_kill_interval: @immediate_kill_interval,
+        immediate_kill_interval_increment: @immediate_kill_interval_increment,
+      }
+    end
+
     def fork(&block)
       if ServerEngine.windows?
         raise NotImplementedError, "fork is not available on this platform. Please use spawn (worker_type: 'spawn')."
@@ -109,7 +127,7 @@ module ServerEngine
           begin
             t = Target.new(wpipe)
             if @enable_heartbeat && @auto_heartbeat
-              HeartbeatThread.new(self, t, @heartbeat_error_proc)
+              HeartbeatThread.new(@heartbeat_interval, t, @heartbeat_error_proc)
             end
 
             block.call(t)
@@ -122,7 +140,7 @@ module ServerEngine
           end
         end
 
-        m = Monitor.new(self, pid)
+        m = Monitor.new(pid, monitor_options)
 
         @monitors << m
         @rpipes[rpipe] = m
@@ -161,9 +179,18 @@ module ServerEngine
           end
         end
 
+        if @command_sender == "pipe"
+          inpipe, @command_sender_pipe = IO.pipe
+          @command_sender_pipe.sync = true
+          @command_sender_pipe.binmode
+          options[:in] = inpipe
+        end
         pid = Process.spawn(env, *args, options)
+        if @command_sender == "pipe"
+          inpipe.close
+        end
 
-        m = Monitor.new(self, pid)
+        m = Monitor.new(pid, monitor_options)
 
         @monitors << m
 
@@ -251,38 +278,28 @@ module ServerEngine
       nil
     end
 
-    def self.format_signal_name(n)
-      Signal.list.each_pair {|k,v|
-        return "SIG#{k}" if n == v
-      }
-      return n
-    end
-
-    def self.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
-
     class AlreadyClosedError < EOFError
     end
 
     HEARTBEAT_MESSAGE = [0].pack('C')
 
     class Monitor
-      def initialize(pm, pid)
-        @pm = pm
+      def initialize(pid, opts={})
         @pid = pid
 
+        @enable_heartbeat = opts[:enable_heartbeat]
+        @heartbeat_timeout = opts[:heartbeat_timeout]
+
+        @graceful_kill_signal   = opts[:graceful_kill_signal]
+        @graceful_kill_timeout  = opts[:graceful_kill_timeout]
+        @graceful_kill_interval = opts[:graceful_kill_interval]
+        @graceful_kill_interval_increment = opts[:graceful_kill_interval_increment]
+
+        @immediate_kill_signal   = opts[:immediate_kill_signal]
+        @immediate_kill_timeout  = opts[:immediate_kill_timeout]
+        @immediate_kill_interval = opts[:immediate_kill_interval]
+        @immediate_kill_interval_increment = opts[:immediate_kill_interval_increment]
+
         @error = false
         @last_heartbeat_time = Time.now
         @next_kill_time = nil
@@ -367,13 +384,13 @@ module ServerEngine
           # check heartbeat timeout or escalation
           if (
               # heartbeat timeout
-              @pm.enable_heartbeat &&
-              heartbeat_delay >= @pm.heartbeat_timeout
+              @enable_heartbeat &&
+              heartbeat_delay >= @heartbeat_timeout
              ) || (
                # escalation
                @graceful_kill_start_time &&
-               @pm.graceful_kill_timeout >= 0 &&
-               @graceful_kill_start_time < now - @pm.graceful_kill_timeout
+               @graceful_kill_timeout >= 0 &&
+               @graceful_kill_start_time < now - @graceful_kill_timeout
              )
             # escalate to immediate kill
             @kill_count = 0
@@ -390,20 +407,20 @@ module ServerEngine
         # send signal now
 
         if @immediate_kill_start_time
-          interval = @pm.immediate_kill_interval
-          interval_incr = @pm.immediate_kill_interval_increment
-          if @pm.immediate_kill_timeout >= 0 &&
-              @immediate_kill_start_time <= now - @pm.immediate_kill_timeout
+          interval = @immediate_kill_interval
+          interval_incr = @immediate_kill_interval_increment
+          if @immediate_kill_timeout >= 0 &&
+              @immediate_kill_start_time <= now - @immediate_kill_timeout
             # escalate to SIGKILL
             signal = :KILL
           else
-            signal = @pm.immediate_kill_signal
+            signal = @immediate_kill_signal
           end
 
         else
-          signal = @pm.graceful_kill_signal
-          interval = @pm.graceful_kill_interval
-          interval_incr = @pm.graceful_kill_interval_increment
+          signal = @graceful_kill_signal
+          interval = @graceful_kill_interval
+          interval_incr = @graceful_kill_interval_increment
         end
 
         begin
@@ -427,8 +444,9 @@ module ServerEngine
     end
 
     class TickThread < Thread
-      def initialize(pm)
-        @pm = pm
+      def initialize(auto_tick_interval, &tick)
+        @auto_tick_interval = auto_tick_interval
+        @tick = tick
         super(&method(:main))
       end
 
@@ -436,7 +454,7 @@ module ServerEngine
 
       def main
         while true
-          @pm.tick(@pm.auto_tick_interval)
+          @tick.call(@auto_tick_interval)
         end
         nil
       rescue AlreadyClosedError
@@ -464,8 +482,8 @@ module ServerEngine
     end
 
     class HeartbeatThread < Thread
-      def initialize(pm, target, error_proc)
-        @pm = pm
+      def initialize(heartbeat_interval, target, error_proc)
+        @heartbeat_interval = heartbeat_interval
         @target = target
         @error_proc = error_proc
         super(&method(:main))
@@ -475,7 +493,7 @@ module ServerEngine
 
       def main
         while true
-          sleep @pm.heartbeat_interval
+          sleep @heartbeat_interval
           @target.heartbeat!
         end
         nil

data/lib/serverengine/server.rb

@@ -15,6 +15,10 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/signals'
+require 'serverengine/signal_thread'
+require 'serverengine/worker'
+
 module ServerEngine
 
   class Server
@@ -24,6 +28,7 @@ module ServerEngine
       @worker_module = worker_module
 
       @stop = false
+      @stop_status = nil
 
       super(load_config_proc, &block)
 
@@ -31,6 +36,9 @@ module ServerEngine
       @log_stderr = !!@config.fetch(:log_stderr, true)
       @log_stdout = false if logdev_from_config(@config) == STDOUT
       @log_stderr = false if logdev_from_config(@config) == STDERR
+
+      @command_sender = @config.fetch(:command_sender, ServerEngine.windows? ? "pipe" : "signal")
+      @command_pipe = @config.fetch(:command_pipe, nil)
     end
 
     def before_run
@@ -64,17 +72,40 @@ module ServerEngine
 
     def install_signal_handlers
       s = self
-      SignalThread.new do |st|
-        st.trap(@config[:signal_graceful_stop] || Daemon::Signals::GRACEFUL_STOP) { s.stop(true) }
-        st.trap(@config[:signal_detach] || Daemon::Signals::DETACH) { s.stop(true) }
-        # Here disables signals excepting GRACEFUL_STOP == :SIGTERM because
-        # only SIGTERM is available on all version of Windows.
-        unless ServerEngine.windows?
-          st.trap(@config[:signal_immediate_stop] || Daemon::Signals::IMMEDIATE_STOP) { s.stop(false) }
-          st.trap(@config[:signal_graceful_restart] || Daemon::Signals::GRACEFUL_RESTART) { s.restart(true) }
-          st.trap(@config[:signal_immediate_restart] || Daemon::Signals::IMMEDIATE_RESTART) { s.restart(false) }
-          st.trap(@config[:signal_reload] || Daemon::Signals::RELOAD) { s.reload }
-          st.trap(@config[:signal_dump] || Daemon::Signals::DUMP) { Sigdump.dump }
+      if @command_pipe
+        Thread.new do
+          until @command_pipe.closed?
+            case @command_pipe.gets.chomp
+            when "GRACEFUL_STOP"
+              s.stop(true)
+            when "IMMEDIATE_STOP"
+              s.stop(false)
+            when "GRACEFUL_RESTART"
+              s.restart(true)
+            when "IMMEDIATE_RESTART"
+              s.restart(false)
+            when "RELOAD"
+              s.reload
+            when "DETACH"
+              s.detach(true)
+            when "DUMP"
+              Sigdump.dump
+            end
+          end
+        end
+      else
+        SignalThread.new do |st|
+          st.trap(@config[:signal_graceful_stop] || Signals::GRACEFUL_STOP) { s.stop(true) }
+          st.trap(@config[:signal_detach] || Signals::DETACH) { s.stop(true) }
+          # Here disables signals excepting GRACEFUL_STOP == :SIGTERM because
+          # only SIGTERM is available on all version of Windows.
+          unless ServerEngine.windows?
+            st.trap(@config[:signal_immediate_stop] || Signals::IMMEDIATE_STOP) { s.stop(false) }
+            st.trap(@config[:signal_graceful_restart] || Signals::GRACEFUL_RESTART) { s.restart(true) }
+            st.trap(@config[:signal_immediate_restart] || Signals::IMMEDIATE_RESTART) { s.restart(false) }
+            st.trap(@config[:signal_reload] || Signals::RELOAD) { s.reload }
+            st.trap(@config[:signal_dump] || Signals::DUMP) { Sigdump.dump }
+          end
         end
       end
     end
@@ -93,6 +124,9 @@ module ServerEngine
       ensure
         after_run
       end
+      if @stop_status
+        raise SystemExit.new(@stop_status)
+      end
     end
 
     module WorkerInitializer

data/lib/serverengine/signal_thread.rb

@@ -19,8 +19,6 @@ module ServerEngine
 
   class SignalThread < Thread
     def initialize(&block)
-      require 'thread'
-
       @handlers = {}
 
       @mutex = Mutex.new

data/lib/serverengine/signals.rb

@@ -0,0 +1,31 @@
+#
+# 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.
+#
+
+require 'serverengine/utils'
+
+module ServerEngine
+  module Signals
+    GRACEFUL_STOP = :TERM
+    IMMEDIATE_STOP = ServerEngine::windows? ? :KILL : :QUIT
+    GRACEFUL_RESTART = :USR1
+    IMMEDIATE_RESTART = :HUP
+    RELOAD = :USR2
+    DETACH = :INT
+    DUMP = :CONT
+  end
+end

data/lib/serverengine/socket_manager.rb

@@ -15,12 +15,12 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'socket'
+require 'ipaddr'
+
 module ServerEngine
   module SocketManager
 
-    require 'socket'
-    require 'ipaddr'
-
     class Client
       def initialize(path)
         @path = path
@@ -157,8 +157,6 @@ module ServerEngine
       Marshal.load(data)
     end
 
-    require_relative 'utils'
-
     if ServerEngine.windows?
       require_relative 'socket_manager_win'
       Client.include(SocketManagerWin::ClientModule)

data/lib/serverengine/socket_manager_unix.rb

@@ -15,6 +15,7 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'socket'
 
 module ServerEngine
   module SocketManagerUnix

data/lib/serverengine/socket_manager_win.rb

@@ -15,12 +15,14 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'socket'
+require 'ipaddr'
+
+require_relative 'winsock'
 
 module ServerEngine
   module SocketManagerWin
 
-    require_relative 'winsock'
-
     module ClientModule
       private
 

data/lib/serverengine/supervisor.rb

@@ -15,6 +15,17 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/config_loader'
+require 'serverengine/blocking_flag'
+require 'serverengine/process_manager'
+require 'serverengine/command_sender'
+require 'serverengine/signals'
+
+require 'serverengine/embedded_server'
+require 'serverengine/multi_process_server'
+require 'serverengine/multi_thread_server'
+require 'serverengine/multi_spawn_server'
+
 module ServerEngine
 
   class Supervisor
@@ -29,8 +40,8 @@ module ServerEngine
 
       @pm = ProcessManager.new(
         auto_tick: false,
-        graceful_kill_signal: Daemon::Signals::GRACEFUL_STOP,
-        immediate_kill_signal: Daemon::Signals::IMMEDIATE_STOP,
+        graceful_kill_signal: Signals::GRACEFUL_STOP,
+        immediate_kill_signal: Signals::IMMEDIATE_STOP,
         enable_heartbeat: true,
         auto_heartbeat: true,
       )
@@ -41,9 +52,19 @@ module ServerEngine
       @server_process_name = @config[:server_process_name]
 
       @restart_server_process = !!@config[:restart_server_process]
+      @unrecoverable_exit_codes = @config.fetch(:unrecoverable_exit_codes, [])
       @enable_detach = !!@config[:enable_detach]
       @exit_on_detach = !!@config[:exit_on_detach]
       @disable_reload = !!@config[:disable_reload]
+
+      @command_pipe = @config.fetch(:command_pipe, nil)
+
+      @command_sender = @config.fetch(:command_sender, ServerEngine.windows? ? "pipe" : "signal")
+      if @command_sender == "pipe"
+        extend CommandSender::Pipe
+      else
+        extend CommandSender::Signal
+      end
     end
 
     # server is available after start_server() call.
@@ -97,16 +118,16 @@ module ServerEngine
 
     def stop(stop_graceful)
       @stop = true
-      send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_STOP : Daemon::Signals::IMMEDIATE_STOP)
+      _stop(stop_graceful)
     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)
+        _stop(stop_graceful)
       else
-        send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_RESTART : Daemon::Signals::IMMEDIATE_RESTART)
+        _restart(stop_graceful)
       end
     end
 
@@ -115,13 +136,13 @@ module ServerEngine
         reload_config
       end
       @logger.reopen! if @logger
-      send_signal(Daemon::Signals::RELOAD)
+      _reload
     end
 
     def detach(stop_graceful)
       if @enable_detach
         @detach_flag.set!
-        send_signal(stop_graceful ? Daemon::Signals::GRACEFUL_STOP : Daemon::Signals::IMMEDIATE_STOP)
+        _stop(stop_graceful)
       else
         stop(stop_graceful)
       end
@@ -129,14 +150,37 @@ module ServerEngine
 
     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 }
+      if @command_pipe
+        Thread.new do
+          until @command_pipe.closed?
+            case @command_pipe.gets.chomp
+            when "GRACEFUL_STOP"
+              s.stop(true)
+            when "IMMEDIATE_STOP"
+              s.stop(false)
+            when "GRACEFUL_RESTART"
+              s.restart(true)
+            when "IMMEDIATE_RESTART"
+              s.restart(false)
+            when "RELOAD"
+              s.reload
+            when "DETACH"
+              s.detach(true)
+            when "DUMP"
+              Sigdump.dump
+            end
+          end
+        end
+      else
+        SignalThread.new do |st|
+          st.trap(Signals::GRACEFUL_STOP) { s.stop(true) }
+          st.trap(Signals::IMMEDIATE_STOP) { s.stop(false) }
+          st.trap(Signals::GRACEFUL_RESTART) { s.restart(true) }
+          st.trap(Signals::IMMEDIATE_RESTART) { s.restart(false) }
+          st.trap(Signals::RELOAD) { s.reload }
+          st.trap(Signals::DETACH) { s.detach(true) }
+          st.trap(Signals::DUMP) { Sigdump.dump }
+        end
       end
     end
 
@@ -151,6 +195,9 @@ module ServerEngine
         until @detach_flag.wait(0.5)
           if try_join
             return if @stop   # supervisor stoppped explicitly
+            if @stop_status # set exit code told by server
+              raise SystemExit.new(@stop_status)
+            end
 
             # child process died unexpectedly.
             # sleep @server_detach_wait sec and reboot process
@@ -184,7 +231,10 @@ module ServerEngine
 
     def try_join
       if stat = @pmon.try_join
-        @logger.info "Server finished#{@stop ? '' : ' unexpectedly'} with #{ProcessManager.format_join_status(stat)}"
+        @logger.info "Server finished#{@stop ? '' : ' unexpectedly'} with #{ServerEngine.format_join_status(stat)}"
+        if !@stop && stat.is_a?(Process::Status) && stat.exited? && @unrecoverable_exit_codes.include?(stat.exitstatus)
+          @stop_status = stat.exitstatus
+        end
         @pmon = nil
         return stat
       else
@@ -194,20 +244,50 @@ module ServerEngine
     end
 
     def start_server
-      s = create_server(logger)
-      @last_start_time = Time.now
+      if @command_sender == "pipe"
+        inpipe, @command_sender_pipe = IO.pipe
+      end
 
-      begin
-        m = @pm.fork do
-          $0 = @server_process_name if @server_process_name
-          s.install_signal_handlers
+      unless ServerEngine.windows?
+        s = create_server(logger)
+        @last_start_time = Time.now
 
-          s.main
+        begin
+          m = @pm.fork do
+            $0 = @server_process_name if @server_process_name
+            if @command_sender == "pipe"
+              @command_sender_pipe.close
+              s.instance_variable_set(:@command_pipe, inpipe)
+            end
+            s.install_signal_handlers
+
+            begin
+              s.main
+            rescue SystemExit => e
+              @logger.info "Server is exitting with code #{e.status}"
+              exit! e.status
+            end
+          end
+          if @command_sender == "pipe"
+            inpipe.close
+          end
+
+          return m
+        ensure
+          s.after_start
+        end
+      else # if ServerEngine.windows?
+        exconfig = {}
+        if @command_sender == "pipe"
+          exconfig[:in] = inpipe
+        end
+        @last_start_time = Time.now
+        m = @pm.spawn(*Array(config[:windows_daemon_cmdline]), exconfig)
+        if @command_sender == "pipe"
+          inpipe.close
         end
 
         return m
-      ensure
-        s.after_start
       end
     end