serverengine 1.5.11 → 1.6.0

data/lib/serverengine/server.rb

@@ -66,12 +66,16 @@ module ServerEngine
       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.stop(true) }
-        st.trap(Daemon::Signals::DUMP) { Sigdump.dump }
+        # Here disables signals excepting GRACEFUL_STOP == :SIGTERM because
+        # only SIGTERM is available on all version of Windows.
+        unless ServerEngine.windows?
+          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::DUMP) { Sigdump.dump }
+        end
       end
     end
 

data/lib/serverengine/socket_manager.rb

@@ -0,0 +1,170 @@
+#
+# 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
+  module SocketManager
+
+    require 'socket'
+    require 'ipaddr'
+
+    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
+          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
+
+    require_relative 'utils'
+
+    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

data/lib/serverengine/socket_manager_unix.rb

@@ -0,0 +1,96 @@
+#
+# 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
+  module SocketManagerUnix
+
+    module ClientModule
+      private
+
+      def connect_peer(path)
+        return UNIXSocket.new(path)
+      end
+
+      def recv_tcp(peer, sent)
+        return peer.recv_io(TCPServer)
+      end
+
+      def recv_udp(peer, sent)
+        return peer.recv_io(UDPSocket)
+      end
+    end
+
+    module ServerModule
+      private
+
+      def listen_tcp_new(bind_ip, port)
+        sock = TCPServer.new(bind_ip.to_s, port)
+        sock.listen(Socket::SOMAXCONN)  # TODO make backlog configurable if necessary
+        return sock
+      end
+
+      def listen_udp_new(bind_ip, port)
+        if bind_ip.ipv6?
+          sock = UDPSocket.new(Socket::AF_INET6)
+        else
+          sock = UDPSocket.new
+        end
+        sock.bind(bind_ip.to_s, port)
+        return sock
+      end
+
+      def start_server(path)
+        # return absolute path so that client can connect to this path
+        # when client changed working directory
+        path = File.expand_path(path)
+
+        @server = UNIXServer.new(path)
+
+        @thread = Thread.new do
+          begin
+            while peer = @server.accept
+              Thread.new(peer, &method(:process_peer))  # process_peer calls send_socket
+            end
+          rescue => e
+            unless @server.closed?
+              ServerEngine.dump_uncaught_error(e)
+            end
+          end
+        end
+
+        return path
+      end
+
+      def stop_server
+        @tcp_sockets.reject! {|key,lsock| lsock.close; true }
+        @udp_sockets.reject! {|key,usock| usock.close; true }
+        @server.close unless @server.closed?
+        @thread.join
+      end
+
+      def send_socket(peer, pid, method, bind, port)
+        sock = send(method, bind, port)  # calls listen_tcp or listen_udp
+
+        SocketManager.send_peer(peer, nil)
+
+        peer.send_io sock
+      end
+    end
+
+  end
+end

data/lib/serverengine/socket_manager_win.rb

@@ -0,0 +1,147 @@
+#
+# 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
+  module SocketManagerWin
+
+    require_relative 'winsock'
+
+    module ClientModule
+      private
+
+      def connect_peer(addr)
+        return TCPSocket.open("127.0.0.1", addr)
+      end
+
+      def recv_tcp(peer, sent)
+        proto = WinSock::WSAPROTOCOL_INFO.from_bin(sent)
+
+        handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_STREAM, 0, proto, 0, 1)
+        if handle == WinSock::INVALID_SOCKET
+          RbWinSock.raise_last_error("WSASocketA(2)")
+        end
+
+        return RbWinSock.wrap_io_handle(TCPServer, handle, 0)
+      end
+
+      def recv_udp(peer, sent)
+        proto = WinSock::WSAPROTOCOL_INFO.from_bin(sent)
+
+        handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_DGRAM, 0, proto, 0, 1)
+        if handle == WinSock::INVALID_SOCKET
+          RbWinSock.raise_last_error("WSASocketA(2)")
+        end
+
+        return RbWinSock.wrap_io_handle(UDPSocket, handle, 0)
+      end
+    end
+
+    module ServerModule
+      private
+
+      def listen_tcp_new(bind_ip, port)
+        sock_addr = Socket.pack_sockaddr_in(port, bind_ip.to_s)
+
+        handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP, nil, 0, 1)
+        if handle == WinSock::INVALID_SOCKET
+          RbWinSock.raise_last_error("WSASocketA(2)")
+        end
+
+        # wrap in TCPServer immediately so that its finalizer safely closes the handle
+        sock = RbWinSock.wrap_io_handle(TCPServer, handle, 0)
+
+        unless WinSock.bind(sock.handle, sock_addr, sock_addr.bytesize) == 0
+          RbWinSock.raise_last_error("bind(2)")
+        end
+        unless WinSock.listen(sock.handle, Socket::SOMAXCONN) == 0
+          RbWinSock.raise_last_error("listen(2)")
+        end
+
+        return sock
+      end
+
+      def listen_udp_new(bind_ip, port)
+        sock_addr = Socket.pack_sockaddr_in(port, bind_ip.to_s)
+
+        handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_DGRAM, Socket::IPPROTO_UDP, nil, 0, 1)
+        if handle == WinSock::INVALID_SOCKET
+          RbWinSock.raise_last_error("WSASocketA(2)")
+        end
+
+        # wrap in UDPSocket immediately so that its finalizer safely closes the handle
+        sock = RbWinSock.wrap_io_handle(UDPSocket, handle, 0)
+
+        unless WinSock.bind(sock.handle, sock_addr, sock_addr.bytesize) == 0
+          RbWinSock.raise_last_error("bind(2)")
+        end
+
+        return sock
+      end
+
+      def htons(h)
+        [h].pack("S").unpack("n")[0]
+      end
+
+      def start_server(addr)
+        # TODO: use TCPServer, but this is risky because using not conflict path is easy,
+        # but using not conflict port is difficult. Then We had better implement using NamedPipe.
+        @server = TCPServer.new("127.0.0.1", addr)
+        @thread = Thread.new do
+          begin
+            while peer = @server.accept
+              Thread.new(peer, &method(:process_peer))  # process_peer calls send_socket
+            end
+          rescue => e
+            unless @server.closed?
+              ServerEngine.dump_uncaught_error(e)
+            end
+          end
+        end
+
+        return path
+      end
+
+      def stop_server
+        @tcp_sockets.reject! {|key,lsock| lsock.close; true }
+        @udp_sockets.reject! {|key,usock| usock.close; true }
+        @server.close unless @server.closed?
+        @thread.join
+      end
+
+      def send_socket(peer, pid, method, bind, port)
+        case method
+        when :listen_tcp
+          sock = listen_tcp(bind, port)
+          type = Socket::SOCK_STREAM
+        when :listen_udp
+          sock = listen_udp(bind, port)
+          type = Socket::SOCK_DGRAM
+        else
+          raise ArgumentError, "Unknown method: #{method.inspect}"
+        end
+
+        proto = WinSock::WSAPROTOCOL_INFO.malloc
+        unless WinSock.WSADuplicateSocketA(sock.handle, pid, proto) == 0
+          RbWinSock.raise_last_error("WSADuplicateSocketA(3)")
+        end
+
+        SocketManager.send_peer(peer, proto.to_bin)
+      end
+    end
+  end
+end

data/lib/serverengine/supervisor.rb

@@ -46,6 +46,9 @@ module ServerEngine
       @disable_reload = !!@config[:disable_reload]
     end
 
+    # server is available after start_server() call.
+    attr_reader :server
+
     def reload_config
       super
 
@@ -89,7 +92,7 @@ module ServerEngine
     end
 
     def create_server(logger)
-      @create_server_proc.call(@load_config_proc, logger)
+      @server = @create_server_proc.call(@load_config_proc, logger)
     end
 
     def stop(stop_graceful)