to allow the OS to select a port for us.
Closes #590.
import functools
from tornado.escape import utf8
-from tornado.httpclient import AsyncHTTPClient
from tornado.iostream import IOStream
from tornado import netutil
-from tornado.testing import AsyncHTTPTestCase, get_unused_port
+from tornado.testing import AsyncHTTPTestCase, bind_unused_port
from tornado.util import b, bytes_type
from tornado.web import Application, RequestHandler, url
def test_chunked_close(self):
# test case in which chunks spread read-callback processing
# over several ioloop iterations, but the connection is already closed.
- port = get_unused_port()
- (sock,) = netutil.bind_sockets(port, address="127.0.0.1")
+ sock, port = bind_unused_port()
with closing(sock):
def write_response(stream, request_data):
stream.write(b("""\
from __future__ import absolute_import, division, with_statement
import datetime
-import socket
import time
from tornado.ioloop import IOLoop
-from tornado.netutil import bind_sockets
-from tornado.testing import AsyncTestCase, get_unused_port
+from tornado.testing import AsyncTestCase, bind_unused_port
from tornado.test.util import unittest
self.wait()
def test_multiple_add(self):
- [sock] = bind_sockets(get_unused_port(), '127.0.0.1',
- family=socket.AF_INET)
+ sock, port = bind_unused_port()
try:
self.io_loop.add_handler(sock.fileno(), lambda fd, events: None,
IOLoop.READ)
from tornado.ioloop import IOLoop
from tornado.iostream import IOStream, SSLIOStream
from tornado.log import gen_log
-from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, get_unused_port, ExpectLog
+from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, bind_unused_port, ExpectLog
from tornado.test.util import unittest
from tornado.util import b
from tornado.web import RequestHandler, Application
raise NotImplementedError()
def make_iostream_pair(self, **kwargs):
- port = get_unused_port()
- [listener] = netutil.bind_sockets(port, '127.0.0.1',
- family=socket.AF_INET)
+ listener, port = bind_unused_port()
streams = [None, None]
def accept_callback(connection, address):
# When a connection is refused, the connect callback should not
# be run. (The kqueue IOLoop used to behave differently from the
# epoll IOLoop in this respect)
- port = get_unused_port()
+ server_socket, port = bind_unused_port()
+ server_socket.close()
stream = IOStream(socket.socket(), self.io_loop)
self.connect_called = False
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.log import gen_log
-from tornado.netutil import bind_sockets
from tornado.process import fork_processes, task_id
from tornado.simple_httpclient import SimpleAsyncHTTPClient
-from tornado.testing import get_unused_port, ExpectLog
+from tornado.testing import bind_unused_port, ExpectLog
from tornado.test.util import unittest
from tornado.web import RequestHandler, Application
def test_multi_process(self):
with ExpectLog(gen_log, "(Starting .* processes|child .* exited|uncaught exception)"):
self.assertFalse(IOLoop.initialized())
- port = get_unused_port()
+ sock, port = bind_unused_port()
def get_url(path):
return "http://127.0.0.1:%d%s" % (port, path)
- sockets = bind_sockets(port, "127.0.0.1")
# ensure that none of these processes live too long
signal.alarm(5) # master process
try:
# finished with status 0
self.assertEqual(e.code, 0)
self.assertTrue(task_id() is None)
- for sock in sockets:
- sock.close()
+ sock.close()
return
try:
if id in (0, 1):
self.assertEqual(id, task_id())
server = HTTPServer(self.get_app())
- server.add_sockets(sockets)
+ server.add_sockets([sock])
IOLoop.instance().start()
elif id == 2:
self.assertEqual(id, task_id())
- for sock in sockets:
- sock.close()
+ sock.close()
# Always use SimpleAsyncHTTPClient here; the curl
# version appears to get confused sometimes if the
# connection gets closed before it's had a chance to
from tornado.simple_httpclient import SimpleAsyncHTTPClient, _DEFAULT_CA_CERTS
from tornado.test.httpclient_test import ChunkHandler, CountdownHandler, HelloWorldHandler
from tornado.test import httpclient_test
-from tornado.testing import AsyncHTTPTestCase, AsyncTestCase, get_unused_port, ExpectLog
+from tornado.testing import AsyncHTTPTestCase, AsyncTestCase, bind_unused_port, ExpectLog
from tornado.test.util import unittest
from tornado.util import b
from tornado.web import RequestHandler, Application, asynchronous, url
self.assertTrue(host_re.match(response.body), response.body)
def test_connection_refused(self):
- port = get_unused_port()
+ server_socket, port = bind_unused_port()
+ server_socket.close()
with ExpectLog(gen_log, ".*"):
self.http_client.fetch("http://localhost:%d/" % port, self.stop)
response = self.wait()
have_twisted = False
from tornado.httpclient import AsyncHTTPClient
+from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.platform.auto import set_close_exec
-from tornado.testing import get_unused_port
+from tornado.testing import bind_unused_port
from tornado.test.util import unittest
from tornado.util import import_object
from tornado.web import RequestHandler, Application
def render_GET(self, request):
return "Hello from twisted!"
site = Site(HelloResource())
- self.twisted_port = get_unused_port()
- self.reactor.listenTCP(self.twisted_port, site, interface='127.0.0.1')
+ port = self.reactor.listenTCP(0, site, interface='127.0.0.1')
+ self.twisted_port = port.getHost().port
def start_tornado_server(self):
class HelloHandler(RequestHandler):
self.write("Hello from tornado!")
app = Application([('/', HelloHandler)],
log_function=lambda x: None)
- self.tornado_port = get_unused_port()
- app.listen(self.tornado_port, address='127.0.0.1', io_loop=self.io_loop)
+ server = HTTPServer(app, io_loop=self.io_loop)
+ sock, self.tornado_port = bind_unused_port()
+ server.add_sockets([sock])
def run_ioloop(self):
self.stop_loop = self.io_loop.stop
from tornado.httpserver import HTTPServer
from tornado.simple_httpclient import SimpleAsyncHTTPClient
from tornado.ioloop import IOLoop
+ from tornado import netutil
except ImportError:
# These modules are not importable on app engine. Parts of this module
# won't work, but e.g. LogTrapTestCase and main() will.
AsyncHTTPClient = None
HTTPServer = None
IOLoop = None
+ netutil = None
SimpleAsyncHTTPClient = None
from tornado.log import gen_log
from tornado.stack_context import StackContext, NullContext
import os
import re
import signal
+import socket
import sys
import time
def get_unused_port():
- """Returns a (hopefully) unused port number."""
+ """Returns a (hopefully) unused port number.
+
+ This function does not guarantee that the port it returns is available,
+ only that a series of get_unused_port calls in a single process return
+ distinct ports.
+
+ **Deprecated**. Use bind_unused_port instead, which is guaranteed
+ to find an unused port.
+ """
global _next_port
port = _next_port
_next_port = _next_port + 1
return port
+def bind_unused_port():
+ """Binds a server socket to an available port on localhost.
+
+ Returns a tuple (socket, port).
+ """
+ [sock] = netutil.bind_sockets(0, 'localhost', family=socket.AF_INET)
+ port = sock.getsockname()[1]
+ return sock, port
+
+
class AsyncTestCase(unittest.TestCase):
"""TestCase subclass for testing IOLoop-based asynchronous code.
self.http_client = self.get_http_client()
self._app = self.get_app()
self.http_server = self.get_http_server()
- self.http_server.listen(self.get_http_port(), address="127.0.0.1")
+ sock, port = bind_unused_port()
+ self.http_server.add_sockets([sock])
+ self.__port = port
def get_http_client(self):
return AsyncHTTPClient(io_loop=self.io_loop)
A new port is chosen for each test.
"""
- if self.__port is None:
- self.__port = get_unused_port()
return self.__port
def get_protocol(self):
* Empty HTTP request arguments are no longer ignored. This applies to
``HTTPRequest.arguments`` and ``RequestHandler.get_argument[s]``
in WSGI and non-WSGI modes.
+* New function `tornado.testing.bind_unused_port` both chooses a port
+ and binds a socket to it, so there is no risk of another process
+ using the same port. ``get_unused_port`` is now deprecated.
Helper functions
----------------
+ .. autofunction:: bind_unused_port
+
.. autofunction:: get_unused_port
projects / thirdparty / tornado.git / commitdiff
