serverengine 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88edf590d3f97fedd199f51227518ffbd83316fd
-  data.tar.gz: 43dba794102f403da6535e19883a7d19034449a2
+  metadata.gz: 9e23d663095d365596482cfc7e95d2263b6c5d64
+  data.tar.gz: 723275d864b001541c2dc7534320483e79d19c60
 SHA512:
-  metadata.gz: e71bfefefd9f62d0ec79b6122bb2308b03b8b8da8cc098993e444b3f27ba5daf23b74460ac219424412368db615b383c0fccd97ca48c9045eb6163996e8b4efd
-  data.tar.gz: ff2a3415ecb2d0f6a35f7e940d7bd9e6a1596aaa7a59c0b3954ca85477e0a6f5cc8015fec8366dce85d2212bd7b83df6834af40653c3712bb3fc38d734940f69
+  metadata.gz: 346188cb66f8e835afde847163f0266caad0154e92da190c2e307ed472aacceed4e9fe20b067f1e5422ef7d281237854e8bfaa941f8243b45917db43f9d6d733
+  data.tar.gz: 122f579082a0792539aa79e1d864f144454243bcdb7091c6962e3350bd738ff049fd282ad61c5f314b14b948c6d3d4ec59343970653d994f1573536d60742747

data/Changelog

@@ -1,3 +1,7 @@
+2016-11-22 version 2.0.3:
+
+* Fix bug about IPv6 handling on Windows
+
 2016-11-17 version 2.0.2:
 
 * Fix bug to make busy loop on Windows

data/lib/serverengine/socket_manager.rb

@@ -26,34 +26,36 @@ module ServerEngine
         @path = path
       end
 
-      def listen_tcp(bind, port)
+      def listen(proto, bind, port)
+        bind_ip = IPAddr.new(IPSocket.getaddress(bind))
+        family = bind_ip.ipv6? ? Socket::AF_INET6 : Socket::AF_INET
+
+        listen_method = case proto
+                        when :tcp then :listen_tcp
+                        when :udp then :listen_udp
+                        else
+                          raise ArgumentError, "unknown protocol: #{proto}"
+                        end
         peer = connect_peer(@path)
         begin
-          SocketManager.send_peer(peer, [Process.pid, :listen_tcp, bind, port])
+          SocketManager.send_peer(peer, [Process.pid, listen_method, bind, port])
           res = SocketManager.recv_peer(peer)
           if res.is_a?(Exception)
             raise res
           else
-            return recv_tcp(peer, res)
+            return send(:recv, family, proto, peer, res)
           end
         ensure
           peer.close
         end
       end
 
+      def listen_tcp(bind, port)
+        listen(:tcp, bind, port)
+      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
+        listen(:udp, bind, port)
       end
     end
 
@@ -94,28 +96,29 @@ module ServerEngine
 
       private
 
-      def listen_tcp(bind, port)
+      def listen(proto, bind, port)
+        sockets, new_method = case proto
+                              when :tcp then [@tcp_sockets, :listen_tcp_new]
+                              when :udp then [@udp_sockets, :listen_udp_new]
+                              else
+                                raise ArgumentError, "invalid protocol: #{proto}"
+                              end
         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)
+          unless sockets.has_key?(key)
+            sockets[key] = send(new_method, bind_ip, port)
           end
+          return sockets[key]
         end
       end
 
-      def listen_udp(bind, port)
-        key, bind_ip = resolve_bind_key(bind, port)
+      def listen_tcp(bind, port)
+        listen(:tcp, bind, port)
+      end
 
-        @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
+      def listen_udp(bind, port)
+        listen(:udp, bind, port)
       end
 
       def resolve_bind_key(bind, port)

data/lib/serverengine/socket_manager_unix.rb

@@ -27,12 +27,22 @@ module ServerEngine
         return UNIXSocket.new(path)
       end
 
-      def recv_tcp(peer, sent)
-        return peer.recv_io(TCPServer)
+      def recv(family, proto, peer, sent)
+        server_class = case proto
+                       when :tcp then TCPServer
+                       when :udp then UDPSocket
+                       else
+                         raise ArgumentError, "invalid protocol: #{proto}"
+                       end
+        peer.recv_io(server_class)
       end
 
-      def recv_udp(peer, sent)
-        return peer.recv_io(UDPSocket)
+      def recv_tcp(family, peer, sent)
+        recv(family, :tcp, peer, sent)
+      end
+
+      def recv_udp(family, peer, sent)
+        recv(family, :udp, peer, sent)
       end
     end
 
@@ -49,7 +59,7 @@ module ServerEngine
         if bind_ip.ipv6?
           sock = UDPSocket.new(Socket::AF_INET6)
         else
-          sock = UDPSocket.new
+          sock = UDPSocket.new(Socket::AF_INET)
         end
         sock.bind(bind_ip.to_s, port)
         return sock

data/lib/serverengine/socket_manager_win.rb

@@ -30,74 +30,77 @@ module ServerEngine
         return TCPSocket.open("127.0.0.1", addr)
       end
 
-      def recv_tcp(peer, sent)
-        proto = WinSock::WSAPROTOCOL_INFO.from_bin(sent)
+      def recv(family, proto, peer, sent)
+        server_class, protocol = case proto
+                                 when :tcp then [TCPServer, Socket::SOCK_STREAM]
+                                 when :udp then [UDPSocket, Socket::SOCK_DGRAM]
+                                 else
+                                   raise ArgumentError, "invalid protocol: #{proto}"
+                                 end
 
-        handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_STREAM, 0, proto, 0, 1)
+        proto_info = WinSock::WSAPROTOCOL_INFO.from_bin(sent)
+
+        handle = WinSock.WSASocketA(family, protocol, 0, proto_info, 0, 1)
         if handle == WinSock::INVALID_SOCKET
           RbWinSock.raise_last_error("WSASocketA(2)")
         end
 
-        return RbWinSock.wrap_io_handle(TCPServer, handle, 0)
+        return RbWinSock.wrap_io_handle(server_class, 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
+      def recv_tcp(family, peer, sent)
+        recv(family, :tcp, peer, sent)
+      end
 
-        return RbWinSock.wrap_io_handle(UDPSocket, handle, 0)
+      def recv_udp(family, peer, sent)
+        recv(family, :udp, peer, sent)
       end
     end
 
     module ServerModule
       private
 
-      def listen_tcp_new(bind_ip, port)
+      TCP_OPTIONS = [Socket::SOCK_STREAM, Socket::IPPROTO_TCP, TCPServer, true]
+      UDP_OPTIONS = [Socket::SOCK_DGRAM, Socket::IPPROTO_UDP, UDPSocket, false]
+
+      def listen_new(proto, bind_ip, port)
+        protocol, proto_info, klass, listen = case proto
+                                              when :tcp then TCP_OPTIONS
+                                              when :udp then UDP_OPTIONS
+                                              else
+                                                raise ArgumentError, "invalid protocol: #{proto}"
+                                              end
+        family = bind_ip.ipv6? ? Socket::AF_INET6 : Socket::AF_INET
+
         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)
+        handle = WinSock.WSASocketA(family, protocol, proto_info, 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)
+        # wrap in TCPServer/UDPSocket immediately so that its finalizer safely closes the handle
+        sock = RbWinSock.wrap_io_handle(klass, 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)
-
-        if IPAddr.new(IPSocket.getaddress(bind_ip.to_s)).ipv4?
-          handle = WinSock.WSASocketA(Socket::AF_INET, Socket::SOCK_DGRAM, Socket::IPPROTO_UDP, nil, 0, 1)
-        else
-          handle = WinSock.WSASocketA(Socket::AF_INET6, Socket::SOCK_DGRAM, Socket::IPPROTO_UDP, nil, 0, 1)
-        end
 
-        if handle == WinSock::INVALID_SOCKET
-          RbWinSock.raise_last_error("WSASocketA(2)")
+        if listen
+          unless WinSock.listen(sock.handle, Socket::SOMAXCONN) == 0
+            RbWinSock.raise_last_error("listen(2)")
+          end
         end
 
-        # wrap in UDPSocket immediately so that its finalizer safely closes the handle
-        sock = RbWinSock.wrap_io_handle(UDPSocket, handle, 0)
+        sock
+      end
 
-        unless WinSock.bind(sock.handle, sock_addr, sock_addr.bytesize) == 0
-          RbWinSock.raise_last_error("bind(2)")
-        end
+      def listen_tcp_new(bind_ip, port)
+        listen_new(:tcp, bind_ip, port)
+      end
 
-        return sock
+      def listen_udp_new(bind_ip, port)
+        listen_new(:udp, bind_ip, port)
       end
 
       def htons(h)

data/lib/serverengine/version.rb

@@ -1,3 +1,3 @@
 module ServerEngine
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

data/spec/socket_manager_spec.rb

@@ -1,57 +1,134 @@
+require 'socket'
 
 describe ServerEngine::SocketManager do
   include_context 'test server and worker'
 
   let(:server_path) do
-    'tmp/socket_manager_test.sock'
+    if ServerEngine.windows?
+      24223
+    else
+      'tmp/socket_manager_test.sock'
+    end
+  end
+
+  let(:test_port) do
+    9101
   end
 
   after(:each) do
-    File.unlink(server_path) if File.exist?(server_path)
+    File.unlink(server_path) if server_path.is_a?(String) && File.exist?(server_path)
   end
 
-  if ServerEngine.windows?
-    let(:server_port) do
-     24223
-    end
+  context 'with thread' do
+    context 'using ipv4' do
+      it 'works' do
+        server = SocketManager::Server.open(server_path)
 
-    let(:test_port) do
-      9101
-    end
+        mutex = Mutex.new
+        server_thread_started = false
 
-    it 'is windows' do
-      SocketManager::Client.is_a?(SocketManagerWin::ClientModule)
-      SocketManager::Server.is_a?(SocketManagerWin::ServerModule)
-    end
+        thread = Thread.new do
+          mutex.lock
+          server_thread_started = true
+
+          begin
+            client = ServerEngine::SocketManager::Client.new(server_path)
+
+            tcp = client.listen_tcp('127.0.0.1', test_port)
+            udp = client.listen_udp('127.0.0.1', test_port)
+
+            incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
+            incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+
+            mutex.unlock
+
+            data, _from = udp.recvfrom(10)
+            incr_test_state(:udp_data_sent) if data == "ok"
+
+            s = tcp.accept
+            s.write("ok")
+            s.close
+          rescue => e
+            p(here: "rescue in server thread", error: e)
+            e.backtrace.each do |bt|
+              STDERR.puts bt
+            end
+            raise
+          ensure
+            tcp.close
+            udp.close
+          end
+        end
 
-    context 'with thread' do
-      it 'works' do
-        server = SocketManager::Server.open(server_port)
+        sleep 0.1 until server_thread_started
+        sleep 0.1 while mutex.locked?
 
-        thread = Thread.new do
+        u = UDPSocket.new(Socket::AF_INET)
+        u.send "ok", 0, '127.0.0.1', test_port
+        u.close
 
-          client = ServerEngine::SocketManager::Client.new(server_port)
-          tcp = client.listen_tcp('127.0.0.1', test_port)
-          udp = client.listen_udp('127.0.0.1', test_port)
+        t = TCPSocket.open('127.0.0.1', test_port)
+        t.read.should == "ok"
+        t.close
 
-          incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
-          incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+        server.close
+        thread.join
 
-          data, _from = udp.recvfrom(10)
-          incr_test_state(:udp_data_sent) if data == "ok"
+        test_state(:is_tcp_server).should == 1
+        test_state(:is_udp_socket).should == 1
+        test_state(:udp_data_sent).should == 1
+      end
+    end
 
-          s = tcp.accept
-          s.write("ok")
-          s.close
+    context 'using ipv6' do
+      it 'works' do
+        server = SocketManager::Server.open(server_path)
+
+        mutex = Mutex.new
+        server_thread_started = false
+
+        thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          mutex.lock
+          server_thread_started = true
+
+          begin
+            client = ServerEngine::SocketManager::Client.new(server_path)
+
+            tcp = client.listen_tcp('::1', test_port)
+            udp = client.listen_udp('::1', test_port)
+
+            incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
+            incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+
+            mutex.unlock
+
+            data, _from = udp.recvfrom(10)
+            incr_test_state(:udp_data_sent) if data == "ok"
+
+            s = tcp.accept
+            s.write("ok")
+            s.close
+          rescue => e
+            p(here: "rescue in server thread", error: e)
+            e.backtrace.each do |bt|
+              STDERR.puts bt
+            end
+            raise
+          ensure
+            tcp.close
+            udp.close
+          end
         end
 
-        sleep 1
+        sleep 0.1 until server_thread_started
+        sleep 0.1 while mutex.locked?
 
-        u = UDPSocket.new
-        u.send "ok", 0, '127.0.0.1', test_port
+        u = UDPSocket.new(Socket::AF_INET6)
+        u.send "ok", 0, '::1', test_port
         u.close
 
-        t = TCPSocket.open('127.0.0.1', test_port)
+        t = TCPSocket.open('::1', test_port)
         t.read.should == "ok"
         t.close
 
@@ -62,13 +139,15 @@ describe ServerEngine::SocketManager do
         test_state(:is_udp_socket).should == 1
         test_state(:udp_data_sent).should == 1
       end
-    end
+    end if (TCPServer.open("::1",0) rescue nil)
+  end
 
-  else
-    let(:test_port) do
-      9102
+  if ServerEngine.windows?
+    it 'is windows' do
+      SocketManager::Client.is_a?(SocketManagerWin::ClientModule)
+      SocketManager::Server.is_a?(SocketManagerWin::ServerModule)
     end
-
+  else
     it 'is unix' do
       SocketManager::Client.is_a?(SocketManagerUnix::ClientModule)
       SocketManager::Server.is_a?(SocketManagerUnix::ServerModule)
@@ -81,20 +160,25 @@ describe ServerEngine::SocketManager do
         fork do
           server.close
 
-          client = server.new_client
+          begin
+            client = server.new_client
 
-          tcp = client.listen_tcp('127.0.0.1', test_port)
-          udp = client.listen_udp('127.0.0.1', test_port)
+            tcp = client.listen_tcp('127.0.0.1', test_port)
+            udp = client.listen_udp('127.0.0.1', test_port)
 
-          incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
-          incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
+            incr_test_state(:is_tcp_server) if tcp.is_a?(TCPServer)
+            incr_test_state(:is_udp_socket) if udp.is_a?(UDPSocket)
 
-          data, _from = udp.recvfrom(10)
-          incr_test_state(:udp_data_sent) if data == "ok"
+            data, _from = udp.recvfrom(10)
+            incr_test_state(:udp_data_sent) if data == "ok"
 
-          s = tcp.accept
-          s.write("ok")
-          s.close
+            s = tcp.accept
+            s.write("ok")
+            s.close
+          ensure
+            tcp.close
+            udp.close
+          end
         end
 
         wait_for_fork

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serverengine
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-17 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sigdump