serverengine 2.0.0pre1-x64-mingw32

data/lib/serverengine/server.rb

@@ -0,0 +1,178 @@
+#
+# 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/signal_thread'
+require 'serverengine/worker'
+
+module ServerEngine
+
+  class Server
+    include ConfigLoader
+
+    def initialize(worker_module, load_config_proc={}, &block)
+      @worker_module = worker_module
+
+      @stop = false
+      @stop_status = nil
+
+      super(load_config_proc, &block)
+
+      @log_stdout = !!@config.fetch(:log_stdout, true)
+      @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
+    end
+
+    def after_run
+    end
+
+    def stop(stop_graceful)
+      @logger.info "Received #{stop_graceful ? 'graceful' : 'immediate'} stop" if @logger
+      @stop = true
+      nil
+    end
+
+    def after_start
+    end
+
+    def restart(stop_graceful)
+      @logger.info "Received #{stop_graceful ? 'graceful' : 'immediate'} restart" if @logger
+      reload_config
+      @logger.reopen! if @logger
+      nil
+    end
+
+    def reload
+      @logger.info "Received reload" if @logger
+      reload_config
+      @logger.reopen! if @logger
+      nil
+    end
+
+    def install_signal_handlers
+      s = self
+      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
+
+    def main
+      create_logger unless @logger
+
+      # start threads to transfer logs from STDOUT/ERR to the logger
+      start_io_logging_thread(STDOUT) if @log_stdout && try_get_io_from_logger(@logger) != STDOUT
+      start_io_logging_thread(STDERR) if @log_stderr && try_get_io_from_logger(@logger) != STDERR
+
+      before_run
+
+      begin
+        run
+      ensure
+        after_run
+      end
+      if @stop_status
+        raise SystemExit.new(@stop_status)
+      end
+    end
+
+    module WorkerInitializer
+      def initialize
+      end
+    end
+
+    private
+
+    # If :logger option is set unexpectedly, reading from STDOUT/ERR
+    # and writing to :logger could cause infinite loop because
+    # :logger may write data to STDOUT/ERR.
+    def try_get_io_from_logger(logger)
+      logdev = logger.instance_eval { @logdev }
+      if logdev.respond_to?(:dev)
+        # ::Logger
+        logdev.dev
+      else
+        # logdev is IO if DaemonLogger. otherwise unknown object including nil
+        logdev
+      end
+    end
+
+    def create_worker(wid)
+      w = Worker.new(self, wid)
+      w.extend(WorkerInitializer)
+      w.extend(@worker_module)
+      w.instance_eval { initialize }
+      w
+    end
+
+    def start_io_logging_thread(io)
+      r, w = IO.pipe
+      io.reopen(w)
+      w.close
+
+      Thread.new do
+        begin
+          while line = r.gets
+            @logger << line
+          end
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+    end
+  end
+
+end

data/lib/serverengine/signal_thread.rb

@@ -0,0 +1,116 @@
+#
+# 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.
+#
+module ServerEngine
+
+  class SignalThread < Thread
+    def initialize(&block)
+      @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) { signal_handler_main(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
+        @finished = true
+        @cond.broadcast
+      end
+      self
+    end
+
+    private
+
+    def signal_handler_main(sig)
+      # here always creates new thread to avoid
+      # complicated race conditin in signal handlers
+      Thread.new do
+        begin
+          enqueue(sig)
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+    end
+
+    def main
+      until @finished
+        sig = nil
+
+        @mutex.synchronize do
+          while true
+            return if @finished
+
+            sig = @queue.shift
+            break if sig
+
+            @cond.wait(@mutex, 1)
+          end
+        end
+
+        begin
+          @handlers[sig].call(sig)
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+
+      nil
+
+    ensure
+      @finished = false
+    end
+
+    def enqueue(sig)
+      @mutex.synchronize do
+        @queue << sig
+        @cond.broadcast
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,171 @@
+#
+# 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 'socket'
+require 'ipaddr'
+
+module ServerEngine
+  module SocketManager
+
+    class Client
+      def initialize(path)
+        @path = path
+      end
+
+      def listen_tcp(bind, port)
+        peer = connect_peer(@path)
+        begin
+          SocketManager.send_peer(peer, [Process.pid, :listen_tcp, bind, port])
+          res = SocketManager.recv_peer(peer)
+          if res.is_a?(Exception)
+            raise res
+          else
+            return recv_tcp(peer, res)
+          end
+        ensure
+          peer.close
+        end
+      end
+
+      def listen_udp(bind, port)
+        peer = connect_peer(@path)
+        begin
+          SocketManager.send_peer(peer, [Process.pid, :listen_udp, bind, port])
+          res = SocketManager.recv_peer(peer)
+          if res.is_a?(Exception)
+            raise res
+          else
+            return recv_udp(peer, res)
+          end
+        ensure
+          peer.close
+        end
+      end
+    end
+
+    class Server
+      def self.generate_path
+        if ServerEngine.windows?
+          for port in 10000..65535
+            if `netstat -na | find "#{port}"`.length == 0
+              return port
+            end
+          end
+        else
+          '/tmp/SERVERENGINE_SOCKETMANAGER_' + Time.now.to_s.gsub(' ', '') + '_' + Process.pid.to_s
+        end
+      end
+
+      def self.open(path)
+        new(path)
+      end
+
+      def initialize(path)
+        @tcp_sockets = {}
+        @udp_sockets = {}
+        @mutex = Mutex.new
+        @path = start_server(path)
+      end
+
+      attr_reader :path
+
+      def new_client
+        Client.new(@path)
+      end
+
+      def close
+        stop_server
+        nil
+      end
+
+      private
+
+      def listen_tcp(bind, port)
+        key, bind_ip = resolve_bind_key(bind, port)
+
+        @mutex.synchronize do
+          if @tcp_sockets.has_key?(key)
+            return @tcp_sockets[key]
+          else
+            return @tcp_sockets[key] = listen_tcp_new(bind_ip, port)
+          end
+        end
+      end
+
+      def listen_udp(bind, port)
+        key, bind_ip = resolve_bind_key(bind, port)
+
+        @mutex.synchronize do
+          if @udp_sockets.has_key?(key)
+            return @udp_sockets[key]
+          else
+            return @udp_sockets[key] = listen_udp_new(bind_ip, port)
+          end
+        end
+      end
+
+      def resolve_bind_key(bind, port)
+        bind_ip = IPAddr.new(IPSocket.getaddress(bind))
+        if bind_ip.ipv6?
+          return "[#{bind_ip}]:#{port}", bind_ip
+        else
+          # assuming ipv4
+          if bind_ip == "127.0.0.1" or bind_ip == "0.0.0.0"
+            return "localhost:#{port}", bind_ip
+          end
+          return "#{bind_ip}:#{port}", bind_ip
+        end
+      end
+
+      def process_peer(peer)
+        while true
+          pid, method, bind, port = *SocketManager.recv_peer(peer)
+          begin
+            send_socket(peer, pid, method, bind, port)
+          rescue => e
+            SocketManager.send_peer(peer, e)
+          end
+        end
+      ensure
+        peer.close
+      end
+    end
+
+    def self.send_peer(peer, obj)
+      data = Marshal.dump(obj)
+      peer.write [data.bytesize].pack('N')
+      peer.write data
+    end
+
+    def self.recv_peer(peer)
+      len = peer.read(4).unpack('N').first
+      data = peer.read(len)
+      Marshal.load(data)
+    end
+
+    if ServerEngine.windows?
+      require_relative 'socket_manager_win'
+      Client.include(SocketManagerWin::ClientModule)
+      Server.include(SocketManagerWin::ServerModule)
+    else
+      require_relative 'socket_manager_unix'
+      Client.include(SocketManagerUnix::ClientModule)
+      Server.include(SocketManagerUnix::ServerModule)
+    end
+
+  end
+end