serverengine 2.0.0pre1-x64-mingw32

data/lib/serverengine/config_loader.rb

@@ -0,0 +1,82 @@
+#
+# 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/daemon_logger'
+
+module ServerEngine
+
+  module ConfigLoader
+    def initialize(load_config_proc={}, &block)
+      if block
+        @load_config_proc = block
+      else
+        if load_config_proc.is_a?(Hash)
+          @load_config_proc = lambda { load_config_proc }
+        else
+          @load_config_proc = load_config_proc
+        end
+      end
+
+      @logger = nil
+
+      reload_config
+    end
+
+    attr_reader :config
+    attr_accessor :logger
+
+    def reload_config
+      @config = @load_config_proc.call
+
+      @logger_class = @config[:logger_class] || DaemonLogger
+
+      if @logger
+        logdev = logdev_from_config(@config)
+        unless logdev.is_a?(IO)
+          # Here doesn't allow to change logdev to IO dynamically
+          # because Server#start_io_logging_thread can't follow it.
+          @logger.logdev = logdev
+        end
+        @logger.level = @config[:log_level] || 'debug'
+      end
+
+      nil
+    end
+
+    private
+
+    def create_logger
+      if logger = @config[:logger]
+        @logger = logger
+      else
+        @logger = @logger_class.new(logdev_from_config(@config), @config)
+      end
+    end
+
+    def logdev_from_config(config)
+      case c = @config[:log]
+      when nil  # default
+        return STDERR
+      when "-"
+        return STDOUT
+      else
+        return c
+      end
+    end
+  end
+
+end

data/lib/serverengine/daemon.rb

@@ -0,0 +1,233 @@
+#
+# 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/command_sender'
+require 'serverengine/config_loader'
+require 'serverengine/privilege'
+require 'serverengine/supervisor'
+
+module ServerEngine
+
+  class Daemon
+    include ConfigLoader
+
+    def initialize(server_module, worker_module, load_config_proc={}, &block)
+      @server_module = server_module
+      @worker_module = worker_module
+
+      super(load_config_proc, &block)
+
+      @daemonize = @config.fetch(:daemonize, false)
+
+      if @config.fetch(:supervisor, false)
+        @create_server_proc = lambda do |_load_config_proc,logger|
+          s = Supervisor.new(server_module, worker_module, _load_config_proc)
+          s.logger = logger
+          s
+        end
+      else
+        @create_server_proc = Supervisor.create_server_proc(server_module, worker_module, @config)
+      end
+
+      @daemon_process_name = @config[:daemon_process_name]
+      @daemonize_error_exit_code = @config[:daemonize_error_exit_code] || 1
+
+      @pid_path = @config[:pid_path]
+      @chuser = @config[:chuser]
+      @chgroup = @config[:chgroup]
+      @chumask = @config[:chumask]
+
+      @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
+        extend ServerEngine::CommandSender::Signal
+      end
+    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
+        exit main
+      rescue => e
+        ServerEngine.dump_uncaught_error(e)
+        exit @daemonize_error_exit_code
+      end
+    end
+
+    def self.run_server(server_module, worker_module, load_config_proc={}, &block)
+      Daemon.new(server_module, worker_module, load_config_proc, &block).server_main
+    end
+
+    def server_main
+      $0 = @daemon_process_name if @daemon_process_name
+
+      Privilege.change(@chuser, @chgroup)
+      File.umask(@chumask) if @chumask
+
+      s = create_server(create_logger)
+
+      STDIN.reopen(File::NULL)
+      STDOUT.reopen(File::NULL, "wb")
+      STDERR.reopen(File::NULL, "wb")
+
+      s.install_signal_handlers
+
+      s.main
+    end
+
+    def main
+      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
+        begin
+          s.main
+        rescue SystemExit => e
+          return e.status
+        end
+        return 0
+      end
+    end
+
+    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)
+
+      write_pid_file
+    end
+
+    def daemonize_with_double_fork(inpipe)
+      rpipe, wpipe = IO.pipe
+      wpipe.sync = true
+
+      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"
+
+            Privilege.change(@chuser, @chgroup)
+            File.umask(@chumask) if @chumask
+
+            s = create_server(create_logger)
+            if @command_sender == "pipe"
+              s.instance_variable_set(:@command_pipe, inpipe)
+            end
+
+            STDIN.reopen(File::NULL)
+            STDOUT.reopen(File::NULL, "wb")
+            STDERR.reopen(File::NULL, "wb")
+
+            s.install_signal_handlers
+
+            wpipe.write "\n"
+            wpipe.close
+
+            begin
+              s.main
+            rescue SystemExit => e
+              exit e.status
+            end
+          end
+
+          exit 0
+        ensure
+          exit! @daemonize_error_exit_code
+        end
+      end
+
+      wpipe.close
+      @pid = rpipe.gets.to_i
+      data = rpipe.read
+      rpipe.close
+
+      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"
+        }
+      end
+    end
+
+    def stop(graceful)
+      _stop(graceful)
+    end
+
+    def restart(graceful)
+      _restart(graceful)
+    end
+
+    def reload
+      _reload
+    end
+
+    def detach
+      _detach
+    end
+
+    def dump
+      _dump
+    end
+
+    private
+
+    def create_server(logger)
+      @server = @create_server_proc.call(@load_config_proc, logger)
+    end
+  end
+end

data/lib/serverengine/daemon_logger.rb

@@ -0,0 +1,135 @@
+#
+# 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 'logger'
+
+module ServerEngine
+
+  class ::Logger::LogDevice
+    def reopen!
+      if filename = @filename
+        @dev.reopen(filename, 'a')
+        @dev.sync = true
+      end
+    end
+  end
+
+  class DaemonLogger < Logger
+    def initialize(logdev, config={})
+      @rotate_age = config[:log_rotate_age] || 5
+      @rotate_size = config[:log_rotate_size] || 1048576
+      @file_dev = nil
+
+      super(nil)
+
+      self.level = config[:log_level] || 'debug'
+      self.logdev = logdev
+    end
+
+    def logdev=(logdev)
+      # overwrites Logger's @logdev variable
+      if logdev.respond_to?(:write) and logdev.respond_to?(:close)
+        # IO
+        @logdev = logdev
+        @logdev.sync = true if @logdev.respond_to?(:sync=)
+        if @file_dev
+          old_file_dev = @file_dev
+          @file_dev = nil
+          old_file_dev.close
+        end
+      elsif !@file_dev || @file_dev.filename != logdev
+        # update path string
+        old_file_dev = @file_dev
+        @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
+      logdev
+    end
+
+    # override add method
+    def add(severity, message = nil, progname = nil, &block)
+      if severity < @level
+        return true
+      end
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = nil
+        end
+      end
+      progname ||= @progname
+      self << format_message(SEVERITY_FORMATS_[severity+1], Time.now, progname, message)
+      true
+    end
+
+    module Severity
+      include Logger::Severity
+      TRACE = -1
+    end
+    include Severity
+
+    SEVERITY_FORMATS_ = %w(TRACE DEBUG INFO WARN ERROR FATAL ANY)
+
+    def level=(expr)
+      case expr.to_s
+      when 'fatal', FATAL.to_s
+        e = FATAL
+      when 'error', ERROR.to_s
+        e = ERROR
+      when 'warn', WARN.to_s
+        e = WARN
+      when 'info', INFO.to_s
+        e = INFO
+      when 'debug', DEBUG.to_s
+        e = DEBUG
+      when 'trace', TRACE.to_s
+        e = TRACE
+      else
+        raise ArgumentError, "invalid log level: #{expr}"
+      end
+
+      super(e)
+    end
+
+    def trace?; @level <= TRACE; end
+
+    def reopen!
+      @file_dev.reopen! if @file_dev
+      nil
+    end
+
+    def reopen
+      begin
+        reopen!
+        return true
+      rescue
+        # TODO log?
+        return false
+      end
+    end
+
+    def close
+      @file_dev.close if @file_dev
+      nil
+    end
+
+  end
+
+end