serverengine 1.6.4 → 2.0.0pre1

data/lib/serverengine/daemon.rb

@@ -15,9 +15,12 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-module ServerEngine
+require 'serverengine/command_sender'
+require 'serverengine/config_loader'
+require 'serverengine/privilege'
+require 'serverengine/supervisor'
 
-  require 'shellwords'
+module ServerEngine
 
   class Daemon
     include ConfigLoader
@@ -47,55 +50,19 @@ module ServerEngine
       @chuser = @config[:chuser]
       @chgroup = @config[:chgroup]
       @chumask = @config[:chumask]
-    end
-
-    # server is available when run() is called. It is a Supervisor instance if supervisor is set to true. Otherwise a Server instance.
-    attr_reader :server
-
-    module Signals
-      GRACEFUL_STOP = :TERM
-      IMMEDIATE_STOP = :QUIT
-      GRACEFUL_RESTART = :USR1
-      IMMEDIATE_RESTART = :HUP
-      RELOAD = :USR2
-      DETACH = :INT
-      DUMP = :CONT
-    end
 
-    def self.get_etc_passwd(user)
-      if user.to_i.to_s == user
-        Etc.getpwuid(user.to_i)
+      @pid = nil
+      @command_pipe = @config.fetch(:command_pipe, nil)
+      @command_sender = @config.fetch(:command_sender, ServerEngine.windows? ? "pipe" : "signal")
+      if @command_sender == "pipe"
+        extend ServerEngine::CommandSender::Pipe
       else
-        Etc.getpwnam(user)
+        extend ServerEngine::CommandSender::Signal
       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_privilege(user, group)
-      if user
-        etc_pw = Daemon.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 = Daemon.get_etc_group(group)
-        Process::GID.change_privilege(etc_group.gid)
-      end
-
-      nil
-    end
+    # server is available when run() is called. It is a Supervisor instance if supervisor is set to true. Otherwise a Server instance.
+    attr_reader :server
 
     def run
       begin
@@ -113,7 +80,7 @@ module ServerEngine
     def server_main
       $0 = @daemon_process_name if @daemon_process_name
 
-      Daemon.change_privilege(@chuser, @chgroup)
+      Privilege.change(@chuser, @chgroup)
       File.umask(@chumask) if @chumask
 
       s = create_server(create_logger)
@@ -128,72 +95,133 @@ module ServerEngine
     end
 
     def main
-      unless @daemonize
+      if @daemonize
+        if @command_sender == "pipe"
+          inpipe, @command_sender_pipe = IO.pipe
+          @command_sender_pipe.sync = true
+          @command_sender_pipe.binmode
+        end
+
+        if ServerEngine.windows?
+          ret = daemonize_with_spawn(inpipe)
+        else
+          ret = daemonize_with_double_fork(inpipe)
+        end
+
+        if @command_sender == "pipe"
+          inpipe.close
+        end
+        return ret
+      else
+        @pid = Process.pid
         s = create_server(create_logger)
         s.install_signal_handlers
-        s.main
+        begin
+          s.main
+        rescue SystemExit => e
+          return e.status
+        end
         return 0
       end
+    end
 
-      rpipe = nil
-      if ServerEngine.windows?
-        windows_daemon_cmdline = config[:windows_daemon_cmdline]
-        pid = Process.spawn(*Array(windows_daemon_cmdline))
-      else
-        rpipe, wpipe = IO.pipe
-        wpipe.sync = true
+    def daemonize_with_spawn(inpipe)
+      windows_daemon_cmdline = config[:windows_daemon_cmdline]
+      config = {}
+      if @command_sender == "pipe"
+        config[:in] = inpipe
+      end
+      @pid = Process.spawn(*Array(windows_daemon_cmdline), config)
 
-        Process.fork do
-          begin
-            rpipe.close
+      write_pid_file
+    end
 
-            Process.setsid
-            Process.fork do
-              $0 = @daemon_process_name if @daemon_process_name
-              wpipe.write "#{Process.pid}\n"
+    def daemonize_with_double_fork(inpipe)
+      rpipe, wpipe = IO.pipe
+      wpipe.sync = true
 
-              Daemon.change_privilege(@chuser, @chgroup)
-              File.umask(@chumask) if @chumask
+      Process.fork do
+        begin
+          rpipe.close
+          if @command_sender == "pipe"
+            @command_sender_pipe.close
+          end
+
+          Process.setsid
+          Process.fork do
+            $0 = @daemon_process_name if @daemon_process_name
+            wpipe.write "#{Process.pid}\n"
 
-              s = create_server(create_logger)
+            Privilege.change(@chuser, @chgroup)
+            File.umask(@chumask) if @chumask
 
-              STDIN.reopen(File::NULL)
-              STDOUT.reopen(File::NULL, "wb")
-              STDERR.reopen(File::NULL, "wb")
+            s = create_server(create_logger)
+            if @command_sender == "pipe"
+              s.instance_variable_set(:@command_pipe, inpipe)
+            end
 
-              s.install_signal_handlers
+            STDIN.reopen(File::NULL)
+            STDOUT.reopen(File::NULL, "wb")
+            STDERR.reopen(File::NULL, "wb")
 
-              wpipe.write "\n"
-              wpipe.close
+            s.install_signal_handlers
 
+            wpipe.write "\n"
+            wpipe.close
+
+            begin
               s.main
+            rescue SystemExit => e
+              exit e.status
             end
-
-            exit 0
-          ensure
-            exit! @daemonize_error_exit_code
           end
+
+          exit 0
+        ensure
+          exit! @daemonize_error_exit_code
         end
+      end
 
-        wpipe.close
+      wpipe.close
+      @pid = rpipe.gets.to_i
+      data = rpipe.read
+      rpipe.close
 
-        pid = rpipe.gets.to_i
+      if data != "\n"
+        return @daemonize_error_exit_code
       end
 
+      write_pid_file
+
+      return 0
+    end
+
+    def write_pid_file
       if @pid_path
         File.open(@pid_path, "w") {|f|
-          f.write "#{pid}\n"
+          f.write "#{@pid}\n"
         }
       end
+    end
 
-      unless ServerEngine.windows?
-        data = rpipe.read
-        if data != "\n"
-          return @daemonize_error_exit_code
-        end
-      end
+    def stop(graceful)
+      _stop(graceful)
+    end
 
-      return 0
+    def restart(graceful)
+      _restart(graceful)
+    end
+
+    def reload
+      _reload
+    end
+
+    def detach
+      _detach
+    end
+
+    def dump
+      _dump
     end
 
     private

data/lib/serverengine/daemon_logger.rb

@@ -15,9 +15,9 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-module ServerEngine
+require 'logger'
 
-  require 'logger'
+module ServerEngine
 
   class ::Logger::LogDevice
     def reopen!
@@ -34,14 +34,6 @@ module ServerEngine
       @rotate_size = config[:log_rotate_size] || 1048576
       @file_dev = nil
 
-      if RUBY_VERSION < "2.1.0"
-        # Ruby < 2.1.0 has a problem around log rotation with multiprocess:
-        # https://github.com/ruby/ruby/pull/428
-        @logdev_class = MultiprocessFileLogDevice
-      else
-        @logdev_class = LogDevice
-      end
-
       super(nil)
 
       self.level = config[:log_level] || 'debug'
@@ -62,7 +54,7 @@ module ServerEngine
       elsif !@file_dev || @file_dev.filename != logdev
         # update path string
         old_file_dev = @file_dev
-        @file_dev = @logdev_class.new(logdev, shift_age: @rotate_age, shift_size: @rotate_size)
+        @file_dev = LogDevice.new(logdev, shift_age: @rotate_age, shift_size: @rotate_size)
         old_file_dev.close if old_file_dev
         @logdev = @file_dev
       end
@@ -138,134 +130,6 @@ module ServerEngine
       nil
     end
 
-    class MultiprocessFileLogDevice
-      def initialize(path, opts={})
-        @shift_age = opts[:shift_age] || 7
-        @shift_size = opts[:shift_size] || 1024*1024
-        @mutex = Mutex.new
-        self.path = path
-      end
-
-      def write(data)
-        # it's hard to remove this synchronize because IO#write raises
-        # Errno::ENOENT if IO#reopen is running concurrently.
-        @mutex.synchronize do
-          unless @file
-            return nil
-          end
-          log_rotate_or_reopen
-          @file.write(data)
-        end
-      rescue Exception => e
-        warn "log writing failed: #{e}"
-      end
-
-      def path=(path)
-        @mutex.synchronize do
-          old_file = @file
-          file = open_logfile(path)
-          begin
-            @file = file
-            @path = path
-            file = old_file
-          ensure
-            file.close if file
-          end
-        end
-        return path
-      end
-
-      def close
-        @mutex.synchronize do
-          @file.close
-          @file = nil
-        end
-        nil
-      end
-
-      def reopen!
-        @mutex.synchronize do
-          if @file
-            @file.reopen(@path, 'a')
-            @file.sync = true
-          end
-        end
-        true
-      end
-
-      # for compatibility with Logger::LogDevice
-      def dev
-        @file
-      end
-
-      # for compatibility with Logger::LogDevice
-      def filename
-        @path
-      end
-
-      private
-
-      def open_logfile(path)
-        return nil unless path
-        file = File.open(path, 'a')
-        file.sync = true
-        return file
-      end
-
-      def log_rotate_or_reopen
-        stat = @file.stat
-        if stat.size <= @shift_size
-          return
-        end
-
-        # inter-process locking
-        retry_limit = 8
-        retry_sleep = 0.1
-        begin
-          # 1) other process is log-rotating now
-          # 2) other process log rotated
-          # 3) no active processes
-          lock = File.open(@path, File::WRONLY | File::APPEND)
-          begin
-            lock.flock(File::LOCK_EX)
-            ino = lock.stat.ino
-            if ino == File.stat(@path).ino and ino == stat.ino
-              # 3)
-              log_rotate
-            else
-              @file.reopen(@path, 'a')
-              @file.sync = true
-            end
-          ensure
-            lock.close
-          end
-        rescue Errno::ENOENT => e
-          raise e if retry_limit <= 0
-          sleep retry_sleep
-          retry_limit -= 1
-          retry_sleep *= 2
-          retry
-        end
-
-      rescue => e
-        warn "log rotation inter-process lock failed: #{e}"
-      end
-
-      def log_rotate
-        (@shift_age-2).downto(0) do |i|
-          old_path = "#{@path}.#{i}"
-          shift_path = "#{@path}.#{i+1}"
-          if FileTest.exist?(old_path)
-            File.rename(old_path, shift_path)
-          end
-        end
-        File.rename(@path, "#{@path}.0")
-        @file.reopen(@path, 'a')
-        @file.sync = true
-      rescue => e
-        warn "log rotation failed: #{e}"
-      end
-    end
   end
 
 end

data/lib/serverengine/embedded_server.rb

@@ -15,6 +15,8 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/server'
+
 module ServerEngine
 
   class EmbeddedServer < Server

data/lib/serverengine/multi_process_server.rb

@@ -15,14 +15,20 @@
 #    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: 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,
         on_heartbeat_error: Proc.new do
@@ -34,6 +40,7 @@ module ServerEngine
       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
@@ -70,7 +77,7 @@ module ServerEngine
           $0 = @worker_process_name % [wid] if @worker_process_name
           w.install_signal_handlers
 
-          Daemon.change_privilege(@chuser, @chgroup)
+          Privilege.change(@chuser, @chgroup)
           File.umask(@chumask) if @chumask
 
           ## recreate the logger created at Server#main
@@ -83,7 +90,7 @@ module ServerEngine
         w.after_start
       end
 
-      return WorkerMonitor.new(w, wid, pmon)
+      return WorkerMonitor.new(w, wid, pmon, unrecoverable_exit_codes: @unrecoverable_exit_codes)
     end
 
     def wait_tick
@@ -91,12 +98,18 @@ module ServerEngine
     end
 
     class WorkerMonitor
-      def initialize(worker, wid, pmon)
+      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
@@ -108,7 +121,7 @@ module ServerEngine
       end
 
       def send_reload
-        @pmon.send_signal(Daemon::Signals::RELOAD) if @pmon
+        @pmon.send_signal(@reload_signal) if @pmon
         nil
       end
 
@@ -121,13 +134,21 @@ module ServerEngine
         return false unless @pmon
 
         if stat = @pmon.try_join
-          @worker.logger.info "Worker #{@wid} finished#{@stop ? '' : ' unexpectedly'} with #{ProcessManager.format_join_status(stat)}"
+          @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
 

data/lib/serverengine/multi_spawn_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/process_manager'
+require 'serverengine/multi_worker_server'
+
 module ServerEngine
 
   class MultiSpawnServer < MultiWorkerServer
@@ -22,15 +26,15 @@ module ServerEngine
       if ServerEngine.windows?
         @pm = ProcessManager.new(
           auto_tick: false,
-          graceful_kill_signal: Daemon::Signals::GRACEFUL_STOP,
+          graceful_kill_signal: Signals::GRACEFUL_STOP,
           immediate_kill_signal: false,
           enable_heartbeat: false,
         )
       else
         @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: false,
         )
       end
@@ -38,6 +42,15 @@ module ServerEngine
       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
@@ -71,26 +84,12 @@ module ServerEngine
         w.after_start
       end
 
-      return WorkerMonitor.new(w, wid, pmon, @reload_signal)
+      return MultiProcessServer::WorkerMonitor.new(w, wid, pmon, @reload_signal, unrecoverable_exit_codes: @unrecoverable_exit_codes)
     end
 
     def wait_tick
       @pm.tick(0.5)
     end
-
-    class WorkerMonitor < MultiProcessServer::WorkerMonitor
-      def initialize(worker, wid, pmon, reload_signal)
-        super(worker, wid, pmon)
-        @reload_signal = reload_signal
-      end
-
-      def send_reload
-        if @reload_signal
-          @pmon.send_signal(@reload_signal) if @pmon
-        end
-        nil
-      end
-    end
   end
 
 end

data/lib/serverengine/multi_thread_server.rb

@@ -15,6 +15,8 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/multi_worker_server'
+
 module ServerEngine
 
   class MultiThreadServer < MultiWorkerServer
@@ -68,6 +70,10 @@ module ServerEngine
       def alive?
         @thread.alive?
       end
+
+      def recoverable?
+        true
+      end
     end
   end
 

data/lib/serverengine/multi_worker_server.rb

@@ -15,6 +15,8 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/server'
+
 module ServerEngine
 
   class MultiWorkerServer < Server
@@ -23,6 +25,8 @@ module ServerEngine
       @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)
@@ -99,6 +103,16 @@ module ServerEngine
           # 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