jython: cb7e31929f49 (original) (raw)

--- a/Lib/socket.py +++ b/Lib/socket.py @@ -413,13 +413,16 @@ class _client_socket_impl(_nio_impl): (IPPROTO_TCP, TCP_NODELAY): 'TcpNoDelay', }

• def init(self, socket=None):

• def init(self, socket=None, pending_options=None): if socket: self.jchannel = socket.getChannel() else: self.jchannel = java.nio.channels.SocketChannel.open() self.jsocket = self.jchannel.socket() self.socketio = org.python.core.io.SocketIO(self.jchannel, 'rw')

•    if pending_options:[](#l1.15)

•        for level, optname in pending_options.keys():[](#l1.16)

•            self.setsockopt(level, optname, pending_options[ (level, optname) ])[](#l1.17)

def bind(self, jsockaddr, reuse_addr): self.jsocket.setReuseAddress(reuse_addr) @@ -485,6 +488,7 @@ class _server_socket_impl(_nio_impl): } def init(self, jsockaddr, backlog, reuse_addr):

•    self.pending_client_options = {}[](#l1.25)
     self.jchannel = java.nio.channels.ServerSocketChannel.open()[](#l1.26)
     self.jsocket = self.jchannel.socket()[](#l1.27)
     self.jsocket.setReuseAddress(reuse_addr)[](#l1.28)

@@ -495,13 +499,13 @@ class _server_socket_impl(_nio_impl): if self.mode in (MODE_BLOCKING, MODE_NONBLOCKING): new_cli_chan = self.jchannel.accept() if new_cli_chan is not None:

•            return _client_socket_impl(new_cli_chan.socket())[](#l1.33)

•            return _client_socket_impl(new_cli_chan.socket(), self.pending_client_options)[](#l1.34)
         else:[](#l1.35)
             return None[](#l1.36)
     else:[](#l1.37)
         # In timeout mode now[](#l1.38)
         new_cli_sock = self.jsocket.accept()[](#l1.39)

•        return _client_socket_impl(new_cli_sock)[](#l1.40)

•        return _client_socket_impl(new_cli_sock, self.pending_client_options)[](#l1.41)

def shutdown(self, how): # This is no-op on java, for server sockets. @@ -510,6 +514,24 @@ class _server_socket_impl(_nio_impl): # later cause the user explicit close() call to fail pass

• def getsockopt(self, level, option):

•    if self.options.has_key( (level, option) ):[](#l1.50)

•        return _nio_impl.getsockopt(self, level, option)[](#l1.51)

•    elif _client_socket_impl.options.has_key( (level, option) ):[](#l1.52)

•        return self.pending_client_options.get( (level, option), None)[](#l1.53)

•    else:[](#l1.54)

•        raise error(errno.ENOPROTOOPT, "Socket option '%s' (level '%s') not supported on socket(%s)" % \[](#l1.55)

•            (_constant_to_name(option, ['SO_', 'TCP_']), _constant_to_name(level,  ['SOL_', 'IPPROTO_']), str(self.jsocket)))[](#l1.56)

+

• def setsockopt(self, level, option, value):

•    if self.options.has_key( (level, option) ):[](#l1.59)

•        _nio_impl.setsockopt(self, level, option, value)[](#l1.60)

•    elif _client_socket_impl.options.has_key( (level, option) ):[](#l1.61)

•        self.pending_client_options[ (level, option) ] = value[](#l1.62)

•    else:[](#l1.63)

•        raise error(errno.ENOPROTOOPT, "Socket option '%s' (level '%s') not supported on socket(%s)" % \[](#l1.64)

•            (_constant_to_name(option, ['SO_', 'TCP_']), _constant_to_name(level,  ['SOL_', 'IPPROTO_']), str(self.jsocket)))[](#l1.65)

+ def getsockname(self): return (self.jsocket.getInetAddress().getHostAddress(), self.jsocket.getLocalPort())

--- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -727,8 +727,9 @@ class TestSocketOptions(unittest.TestCas self._testSetAndGetOption(sock, level, option, values) # now bind the socket i.e. cause the implementation socket to be created sock.bind( (HOST, PORT) )

•        self.failUnlessEqual(sock.getsockopt(level, option), values[-1], \[](#l2.7)

•             "Option value '(%s, %s)'='%s' did not propagate to implementation socket" % (level, option, values[-1]) )[](#l2.8)

•        retrieved_option_value = sock.getsockopt(level, option)[](#l2.9)

•        self.failUnlessEqual(retrieved_option_value, values[-1], \[](#l2.10)

•             "Option value '(%s, %s)'='%s' did not propagate to implementation socket: got %s" % (level, option, values[-1], retrieved_option_value) )[](#l2.11)
         self._testSetAndGetOption(sock, level, option, values)[](#l2.12)
     finally:[](#l2.13)
         sock.close()[](#l2.14)

@@ -738,6 +739,7 @@ class TestSocketOptions(unittest.TestCas try: # First listen on a server socket, so that the connection won't be refused. server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

•        server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)[](#l2.19)
         server_sock.bind( (HOST, PORT) )[](#l2.20)
         server_sock.listen(50)[](#l2.21)
         # Now do the tests[](#l2.22)

@@ -747,35 +749,66 @@ class TestSocketOptions(unittest.TestCas # First bind, so that the SO_REUSEADDR setting propagates sock.bind( (HOST, PORT+1) ) sock.connect( (HOST, PORT) )

•        msg = "Option value '%s'='%s' did not propagate to implementation socket" % (option, values[-1])[](#l2.27)

•        retrieved_option_value = sock.getsockopt(level, option)[](#l2.28)

•        msg = "Option value '%s'='%s' did not propagate to implementation socket: got %s" % (option, values[-1], retrieved_option_value)[](#l2.29)
         if option in (socket.SO_RCVBUF, socket.SO_SNDBUF):[](#l2.30)
             # NOTE: there's no guarantee that bufsize will be the[](#l2.31)
             # exact setsockopt value, particularly after[](#l2.32)
             # establishing a connection. seems it will be *at least*[](#l2.33)
             # the values we test (which are rather small) on[](#l2.34)
             # BSDs.[](#l2.35)

•            self.assert_(sock.getsockopt(level, option) >= values[-1], msg)[](#l2.36)

•            self.assert_(retrieved_option_value >= values[-1], msg)[](#l2.37)
         else:[](#l2.38)

•            self.failUnlessEqual(sock.getsockopt(level, option), values[-1], msg)[](#l2.39)

•            self.failUnlessEqual(retrieved_option_value, values[-1], msg)[](#l2.40)
         self._testSetAndGetOption(sock, level, option, values)[](#l2.41)
     finally:[](#l2.42)
         server_sock.close()[](#l2.43)
         if sock:[](#l2.44)
             sock.close()[](#l2.45)

• def _testTCPClientInheritedOption(self, level, option, values):

•    cli_sock = accepted_sock = None[](#l2.48)

•    try:[](#l2.49)

•        server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)[](#l2.50)

•        server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)[](#l2.51)

•        self._testSetAndGetOption(server_sock, level, option, values)[](#l2.52)

•        # now bind and listen on the socket i.e. cause the implementation socket to be created[](#l2.53)

•        server_sock.bind( (HOST, PORT) )[](#l2.54)

•        server_sock.listen(50)[](#l2.55)

•        # Now create client socket to connect to server[](#l2.56)

•        cli_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)[](#l2.57)

•        cli_sock.connect( (HOST, PORT) )[](#l2.58)

•        accepted_sock = server_sock.accept()[0][](#l2.59)

•        retrieved_option_value = accepted_sock.getsockopt(level, option)[](#l2.60)

•        msg = "Option value '(%s,%s)'='%s' did not propagate to accepted socket: got %s" % (level, option, values[-1], retrieved_option_value)[](#l2.61)

•        if option == socket.SO_RCVBUF:[](#l2.62)

•            # NOTE: see similar bsd/solaris workaround above[](#l2.63)

•            self.assert_(retrieved_option_value >= values[-1], msg)[](#l2.64)

•        else:[](#l2.65)

•            self.failUnlessEqual(retrieved_option_value, values[-1], msg)[](#l2.66)

•        self._testSetAndGetOption(accepted_sock, level, option, values)[](#l2.67)

•    finally:[](#l2.68)

•        server_sock.close()[](#l2.69)

•        if cli_sock:[](#l2.70)

•            cli_sock.close()[](#l2.71)

•        if accepted_sock:[](#l2.72)

•            accepted_sock.close()[](#l2.73)

+ def _testTCPServerOption(self, level, option, values): try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

•        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)[](#l2.78)
         self._testSetAndGetOption(sock, level, option, values)[](#l2.79)
         # now bind and listen on the socket i.e. cause the implementation socket to be created[](#l2.80)
         sock.bind( (HOST, PORT) )[](#l2.81)
         sock.listen(50)[](#l2.82)

•        msg = "Option value '(%s,%s)'='%s' did not propagate to implementation socket" % (level, option, values[-1])[](#l2.83)

•        if is_solaris and option == socket.SO_RCVBUF:[](#l2.84)

•        retrieved_option_value = sock.getsockopt(level, option)[](#l2.85)

•        msg = "Option value '(%s,%s)'='%s' did not propagate to implementation socket. Got %s" % (level, option, values[-1], retrieved_option_value)[](#l2.86)

•        if option == socket.SO_RCVBUF:[](#l2.87)
             # NOTE: see similar bsd/solaris workaround above[](#l2.88)

•            self.assert_(sock.getsockopt(level, option) >= values[-1], msg)[](#l2.89)

•            self.assert_(retrieved_option_value >= values[-1], msg)[](#l2.90)
         else:[](#l2.91)

•            self.failUnlessEqual(sock.getsockopt(level, option), values[-1], msg)[](#l2.92)

•            self.failUnlessEqual(retrieved_option_value, values[-1], msg)[](#l2.93)
         self._testSetAndGetOption(sock, level, option, values)[](#l2.94)
     finally:[](#l2.95)
         sock.close()[](#l2.96)

@@ -783,8 +816,8 @@ class TestSocketOptions(unittest.TestCas def _testOption(self, level, option, values): for flag, func in [ (self.test_udp, self._testUDPOption),

•        (self.test_tcp_client, self._testTCPClientOption),[](#l2.101)
         (self.test_tcp_server, self._testTCPServerOption),[](#l2.102)

•        (self.test_tcp_client, self._testTCPClientOption),[](#l2.103)
     ]:[](#l2.104)
         if flag:[](#l2.105)
             func(level, option, values)[](#l2.106)

@@ -798,6 +831,12 @@ class TestSocketOptions(unittest.TestCas else: self.fail("Setting unsupported option should have raised an exception")

• def _testInheritedOption(self, level, option, values):

•    try:[](#l2.112)

•        self._testTCPClientInheritedOption(level, option, values)[](#l2.113)

•    except Exception, x:[](#l2.114)

•        self.fail("Inherited option should not have raised exception: %s" % str(x))[](#l2.115)

+ class TestSupportedOptions(TestSocketOptions): def testSO_BROADCAST(self): @@ -806,44 +845,58 @@ class TestSupportedOptions(TestSocketOpt def testSO_KEEPALIVE(self): self.test_tcp_client = 1

•    self.test_tcp_server = 1[](#l2.124)
     self._testOption(socket.SOL_SOCKET, socket.SO_KEEPALIVE, [0, 1])[](#l2.125)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_KEEPALIVE, [0, 1])[](#l2.126)

def testSO_LINGER(self): self.test_tcp_client = 1

•    self.test_tcp_server = 1[](#l2.130)
     off = struct.pack('ii', 0, 0)[](#l2.131)
     on_2_seconds = struct.pack('ii', 1, 2)[](#l2.132)
     self._testOption(socket.SOL_SOCKET, socket.SO_LINGER, [off, on_2_seconds])[](#l2.133)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_LINGER, [off, on_2_seconds])[](#l2.134)

def testSO_OOBINLINE(self): self.test_tcp_client = 1

•    self.test_tcp_server = 1[](#l2.138)
     self._testOption(socket.SOL_SOCKET, socket.SO_OOBINLINE, [0, 1])[](#l2.139)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_OOBINLINE, [0, 1])[](#l2.140)

def testSO_RCVBUF(self):

•    self.test_udp = 1[](#l2.143)

•    self.test_udp        = 1[](#l2.144)
     self.test_tcp_client = 1[](#l2.145)
     self.test_tcp_server = 1[](#l2.146)
     self._testOption(socket.SOL_SOCKET, socket.SO_RCVBUF, [1024, 4096, 16384])[](#l2.147)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_RCVBUF, [1024, 4096, 16384])[](#l2.148)

def testSO_REUSEADDR(self):

•    self.test_udp = 1[](#l2.151)

•    self.test_udp        = 1[](#l2.152)
     self.test_tcp_client = 1[](#l2.153)
     self.test_tcp_server = 1[](#l2.154)
     self._testOption(socket.SOL_SOCKET, socket.SO_REUSEADDR, [0, 1])[](#l2.155)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_REUSEADDR, [0, 1])[](#l2.156)

def testSO_SNDBUF(self):

•    self.test_udp = 1[](#l2.159)

•    self.test_udp        = 1[](#l2.160)
     self.test_tcp_client = 1[](#l2.161)

•    self.test_tcp_server = 1[](#l2.162)
     self._testOption(socket.SOL_SOCKET, socket.SO_SNDBUF, [1024, 4096, 16384])[](#l2.163)

•    self._testInheritedOption(socket.SOL_SOCKET, socket.SO_SNDBUF, [1024, 4096, 16384])[](#l2.164)

def testSO_TIMEOUT(self):

•    self.test_udp = 1[](#l2.167)

•    self.test_udp        = 1[](#l2.168)
     self.test_tcp_client = 1[](#l2.169)
     self.test_tcp_server = 1[](#l2.170)
     self._testOption(socket.SOL_SOCKET, socket.SO_TIMEOUT, [0, 1, 1000])[](#l2.171)

•    # We don't test inheritance here because both server and client sockets have SO_TIMEOUT[](#l2.172)

•    # but it doesn't inherit.[](#l2.173)

def testTCP_NODELAY(self): self.test_tcp_client = 1

•    self.test_tcp_server = 1[](#l2.177)
     self._testOption(socket.IPPROTO_TCP, socket.TCP_NODELAY, [0, 1])[](#l2.178)

•    self._testInheritedOption(socket.IPPROTO_TCP, socket.TCP_NODELAY, [0, 1])[](#l2.179)

class TestUnsupportedOptions(TestSocketOptions):