def get_free_port(port, port_retries):
for port in random_ports(port, port_retries+1):
try:
s = socket.socket()
s.bind(('', port))
port = s.getsockname()[1]
s.close()
return port
except socket.error as e:
if e.errno == errno.EADDRINUSE:
print('The port %i is already in use, trying another port.' % port)
continue
elif e.errno in (errno.EACCES, getattr(errno, 'WSAEACCES', errno.EACCES)):
print("Permission to listen on port %i denied" % port)
continue
else:
raise
return None
# http://stackoverflow.com/questions/13593223/making-sure-a-python-script-with-subprocesses-dies-on-sigint
python类EADDRINUSE的实例源码
def test_create_server_addr_in_use(self):
sock_ob = socket.socket(type=socket.SOCK_STREAM)
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock_ob.bind(('0.0.0.0', 0))
f = self.loop.create_server(MyProto, sock=sock_ob)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
f = self.loop.create_server(MyProto, host=host, port=port)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
server.close()
def test_bind_by_addr(self, llc, raw, ldl, dlc):
llc.bind(raw, 16)
assert llc.getsockname(raw) == 16
for i, sock in enumerate([ldl, dlc]):
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(sock, 16)
assert excinfo.value.errno == errno.EACCES
llc.bind(ldl, 63)
assert llc.getsockname(ldl) == 63
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(dlc, 63)
assert excinfo.value.errno == errno.EADDRINUSE
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(dlc, 64)
assert excinfo.value.errno == errno.EFAULT
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(dlc, -1)
assert excinfo.value.errno == errno.EFAULT
llc.bind(dlc, 62)
assert llc.getsockname(dlc) == 62
def test_bind_by_name(self, llc, raw, ldl, dlc):
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(dlc, 'urn:nfc:snep')
assert excinfo.value.errno == errno.EFAULT
llc.bind(dlc, 'urn:nfc:sn:snep')
assert llc.getsockname(dlc) == 4
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(ldl, 'urn:nfc:sn:snep')
assert excinfo.value.errno == errno.EADDRINUSE
llc.bind(ldl, 'urn:nfc:xsn:nfcpy.org:service')
assert llc.getsockname(ldl) == 16
for sap in range(17, 32):
sock = llc.socket(nfc.llcp.llc.RAW_ACCESS_POINT)
llc.bind(sock, 'urn:nfc:sn:use_sap-{}'.format(sap))
assert llc.getsockname(sock) == sap
with pytest.raises(nfc.llcp.Error) as excinfo:
llc.bind(raw, 'urn:nfc:sn:sap-32')
assert excinfo.value.errno == errno.EADDRNOTAVAIL
def _bind_by_name(self, socket, name):
if not service_name_format.match(name):
raise err.Error(errno.EFAULT)
with self.lock:
if self.snl.get(name) is not None:
raise err.Error(errno.EADDRINUSE)
addr = wks_map.get(name)
if addr is None:
try:
addr = 16 + self.sap[16:32].index(None)
except ValueError:
raise err.Error(errno.EADDRNOTAVAIL)
socket.bind(addr)
self.sap[addr] = ServiceAccessPoint(addr, self)
self.sap[addr].insert_socket(socket)
self.snl[name] = addr
def _bind_with_timeout(bind_function, args, n_tries=3, retry_interval_s=0.5):
"""Attempt to bind a socket a number of times with a short interval in between
Especially on Linux, crashing out of a networkzero process can leave the sockets
lingering and unable to re-bind on startup. We give it a few goes here to see if
we can bind within a couple of seconds.
"""
n_tries_left = n_tries
while n_tries_left > 0:
try:
return bind_function(*args)
except zmq.error.ZMQError as exc:
_logger.warn("%s; %d tries remaining", exc, n_tries_left)
n_tries_left -= 1
except OSError as exc:
if exc.errno == errno.EADDRINUSE:
_logger.warn("%s; %d tries remaining", exc, n_tries_left)
n_tries_left -= 1
else:
raise
else:
raise core.SocketAlreadyExistsError("Failed to bind after %s tries" % n_tries)
def test_getsockaddrarg(self):
sock = socket.socket()
self.addCleanup(sock.close)
port = test_support.find_unused_port()
big_port = port + 65536
neg_port = port - 65536
self.assertRaises(OverflowError, sock.bind, (HOST, big_port))
self.assertRaises(OverflowError, sock.bind, (HOST, neg_port))
# Since find_unused_port() is inherently subject to race conditions, we
# call it a couple times if necessary.
for i in itertools.count():
port = test_support.find_unused_port()
try:
sock.bind((HOST, port))
except OSError as e:
if e.errno != errno.EADDRINUSE or i == 5:
raise
else:
break
def test_getsockaddrarg(self):
sock = socket.socket()
self.addCleanup(sock.close)
port = test_support.find_unused_port()
big_port = port + 65536
neg_port = port - 65536
self.assertRaises(OverflowError, sock.bind, (HOST, big_port))
self.assertRaises(OverflowError, sock.bind, (HOST, neg_port))
# Since find_unused_port() is inherently subject to race conditions, we
# call it a couple times if necessary.
for i in itertools.count():
port = test_support.find_unused_port()
try:
sock.bind((HOST, port))
except OSError as e:
if e.errno != errno.EADDRINUSE or i == 5:
raise
else:
break
def test__allocate_sockets(self):
"""Test allocating sockets.
"""
# access protected module _allocate_sockets
# pylint: disable=w0212
socket.socket.bind.side_effect = [
socket.error(errno.EADDRINUSE, 'In use'),
mock.DEFAULT,
mock.DEFAULT,
mock.DEFAULT
]
sockets = treadmill.runtime._allocate_sockets(
'prod', '0.0.0.0', socket.SOCK_STREAM, 3
)
self.assertEqual(3, len(sockets))
def test_getsockaddrarg(self):
sock = socket.socket()
self.addCleanup(sock.close)
port = test_support.find_unused_port()
big_port = port + 65536
neg_port = port - 65536
self.assertRaises((OverflowError, ValueError), sock.bind, (HOST, big_port))
self.assertRaises((OverflowError, ValueError), sock.bind, (HOST, neg_port))
# Since find_unused_port() is inherently subject to race conditions, we
# call it a couple times if necessary.
for i in itertools.count():
port = test_support.find_unused_port()
try:
sock.bind((HOST, port))
except OSError as e:
if e.errno != errno.EADDRINUSE or i == 5:
raise
else:
break
def test_getsockaddrarg(self):
sock = socket.socket()
self.addCleanup(sock.close)
port = support.find_unused_port()
big_port = port + 65536
neg_port = port - 65536
self.assertRaises(OverflowError, sock.bind, (HOST, big_port))
self.assertRaises(OverflowError, sock.bind, (HOST, neg_port))
# Since find_unused_port() is inherently subject to race conditions, we
# call it a couple times if necessary.
for i in itertools.count():
port = support.find_unused_port()
try:
sock.bind((HOST, port))
except OSError as e:
if e.errno != errno.EADDRINUSE or i == 5:
raise
else:
break
def test_create_server_addr_in_use(self):
sock_ob = socket.socket(type=socket.SOCK_STREAM)
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock_ob.bind(('0.0.0.0', 0))
f = self.loop.create_server(MyProto, sock=sock_ob)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
f = self.loop.create_server(MyProto, host=host, port=port)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
server.close()
def test_retry_limited(self):
inet4_servers = [self.mox.CreateMock(wsgi_server._SingleAddressWsgiServer)
for _ in range(wsgi_server._PORT_0_RETRIES)]
inet6_servers = [self.mox.CreateMock(wsgi_server._SingleAddressWsgiServer)
for _ in range(wsgi_server._PORT_0_RETRIES)]
self.mox.StubOutWithMock(wsgi_server, '_SingleAddressWsgiServer')
self.mox.StubOutWithMock(socket, 'getaddrinfo')
socket.getaddrinfo('localhost', 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
socket.AI_PASSIVE).AndReturn(
[(None, None, None, None, ('127.0.0.1', 0, 'baz')),
(None, None, None, None, ('::1', 0, 'baz'))])
for offset, (inet4_server, inet6_server) in enumerate(zip(
inet4_servers, inet6_servers)):
wsgi_server._SingleAddressWsgiServer(('127.0.0.1', 0), None).AndReturn(
inet4_server)
inet4_server.start()
inet4_server.port = offset + 1
wsgi_server._SingleAddressWsgiServer(('::1', offset + 1), None).AndReturn(
inet6_server)
inet6_server.start().AndRaise(
wsgi_server.BindError('message', (errno.EADDRINUSE, 'in use')))
inet4_server.quit()
self.mox.ReplayAll()
self.assertRaises(wsgi_server.BindError, self.server.start)
self.mox.VerifyAll()
def find_available_port(port_range=(49152, 65535), max_tries=1000):
low, high = port_range
port = low
try_no = 0
while try_no < max_tries:
try_no += 1
port = random.randint(low, high)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.bind(('127.0.0.1', port))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
continue
finally:
sock.close()
break
else:
port = None
return port
def test_getsockaddrarg(self):
sock = socket.socket()
self.addCleanup(sock.close)
port = support.find_unused_port()
big_port = port + 65536
neg_port = port - 65536
self.assertRaises(OverflowError, sock.bind, (HOST, big_port))
self.assertRaises(OverflowError, sock.bind, (HOST, neg_port))
# Since find_unused_port() is inherently subject to race conditions, we
# call it a couple times if necessary.
for i in itertools.count():
port = support.find_unused_port()
try:
sock.bind((HOST, port))
except OSError as e:
if e.errno != errno.EADDRINUSE or i == 5:
raise
else:
break
def test_create_server_addr_in_use(self):
sock_ob = socket.socket(type=socket.SOCK_STREAM)
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock_ob.bind(('0.0.0.0', 0))
f = self.loop.create_server(MyProto, sock=sock_ob)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
f = self.loop.create_server(MyProto, host=host, port=port)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
server.close()
def _lock(self):
if OS == 'Linux':
so = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
addr = '\0/portlock/' + self.key
so.bind(addr)
self.socks[0] = so
logger.debug('success to bind: {addr}'.format(addr=addr))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
logger.debug('failure to bind: {addr}'.format(addr=addr))
else:
raise
return
# other OS
for i in range(len(self.socks)):
addr = (self.addr[0], self.addr[1] + i)
so = self._socket()
try:
so.bind(addr)
self.socks[i] = so
logger.debug('success to bind: {addr}'.format(addr=addr))
except socket.error as e:
if e.errno == errno.EADDRINUSE:
logger.debug('failure to bind: {addr}'.format(addr=addr))
else:
raise
def _listen(host, start_port, end_port, listen_func):
try_port = start_port
while True:
try:
return listen_func((host, try_port))
except socket.error as exc:
if (exc.errno != errno.EADDRINUSE or
try_port >= end_port):
raise
try_port += 1
def run(self):
"""
Sets up the live server and databases, and then loops over handling
http requests.
"""
if self.connections_override:
# Override this thread's database connections with the ones
# provided by the main thread.
for alias, conn in self.connections_override.items():
connections[alias] = conn
try:
# Create the handler for serving static and media files
handler = self.static_handler(_MediaFilesHandler(WSGIHandler()))
# Go through the list of possible ports, hoping that we can find
# one that is free to use for the WSGI server.
for index, port in enumerate(self.possible_ports):
try:
self.httpd = self._create_server(port)
except socket.error as e:
if (index + 1 < len(self.possible_ports) and
e.errno == errno.EADDRINUSE):
# This port is already in use, so we go on and try with
# the next one in the list.
continue
else:
# Either none of the given ports are free or the error
# is something else than "Address already in use". So
# we let that error bubble up to the main thread.
raise
else:
# A free port was found.
self.port = port
break
self.httpd.set_app(handler)
self.is_ready.set()
self.httpd.serve_forever()
except Exception as e:
self.error = e
self.is_ready.set()
def test_create_connection_local_addr_in_use(self):
with test_utils.run_test_server() as httpd:
f = self.loop.create_connection(
lambda: MyProto(loop=self.loop),
*httpd.address, local_addr=httpd.address)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
self.assertIn(str(httpd.address), cm.exception.strerror)
def test_create_server_dual_stack(self):
f_proto = asyncio.Future(loop=self.loop)
class TestMyProto(MyProto):
def connection_made(self, transport):
super().connection_made(transport)
f_proto.set_result(self)
try_count = 0
while True:
try:
port = support.find_unused_port()
f = self.loop.create_server(TestMyProto, host=None, port=port)
server = self.loop.run_until_complete(f)
except OSError as ex:
if ex.errno == errno.EADDRINUSE:
try_count += 1
self.assertGreaterEqual(5, try_count)
continue
else:
raise
else:
break
client = socket.socket()
client.connect(('127.0.0.1', port))
client.send(b'xxx')
proto = self.loop.run_until_complete(f_proto)
proto.transport.close()
client.close()
f_proto = asyncio.Future(loop=self.loop)
client = socket.socket(socket.AF_INET6)
client.connect(('::1', port))
client.send(b'xxx')
proto = self.loop.run_until_complete(f_proto)
proto.transport.close()
client.close()
server.close()
def open(cls, owner=None):
port = -1
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
for i in range(25672, 35672):
port = i
try:
listener.bind(("127.0.0.1", port))
break
except socket.error as err:
if err.errno != errno.EADDRINUSE:
log.error("%s: pipe socket bind failed %s", owner, err)
raise
listener.listen(1)
client = None
server = None
try:
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.setblocking(False)
client.connect_ex(("127.0.0.1", port))
server, address = listener.accept()
log.info("%s: pipe accepted socket from %s", owner, address)
client.setblocking(True)
code = generate_uuid().bytes
client.sendall(code)
code2 = Pipe._recvall(server, len(code))
if code != code2:
raise IOError(errno.EIO, "Pipe handshake failed")
pipe = Pipe()
pipe.sink = client
pipe.source = server
return pipe
except:
if client:
client.close()
if server:
server.close()
raise
finally:
listener.close()
def _bind_socket(self, time_to_return):
addr = ('0.0.0.0', self.addr[1])
while time.time() < time_to_return:
log.debug("trying to bind socket to %s:%d", *addr)
try:
self.socket.bind(addr)
return True
except socket.error as error:
log.debug("bind failed with %s", error)
if error.errno == errno.EADDRINUSE:
return False
else:
raise error
def _bind_by_addr(self, socket, addr):
if addr < 0 or addr > 63:
raise err.Error(errno.EFAULT)
with self.lock:
if addr in range(32, 64) or isinstance(socket, tco.RawAccessPoint):
if self.sap[addr] is None:
socket.bind(addr)
self.sap[addr] = ServiceAccessPoint(addr, self)
self.sap[addr].insert_socket(socket)
else:
raise err.Error(errno.EADDRINUSE)
else:
raise err.Error(errno.EACCES)
def new_rtp_socket(host, version=4):
'''
Get and return free socket address from the system in the rtp
range 16382 <= port < 32767.
Parameters
----------
host : string
hostname or ip for which a socket addr is needed
Returns
-------
ip, port : string, int
Notes
-----
Due to common usage with SIPp (which uses every rtp port
and that port + 2) we have the rule that we skip forward
by two on evey second call since N+2, (N+1)+2, will be
already taken up and the next available will be (N+1)+2+1
'''
err = None
for _ in range(5):
try:
return get_new_sock(
host, port=next(_rtp_port_gen), version=version)
except socket.error as e:
# If we failed to bind, lets try again. Otherwise reraise
# the error immediately as its something much more serious.
if e.errno != errno.EADDRINUSE:
raise
err = e
raise err
def _start_beacon(port=None):
"""Start a beacon thread within this process if no beacon is currently
running on this machine.
In general this is called automatically when an attempt is made to
advertise or discover. It might be convenient, though, to call this
function directly if you want to have a process whose only job is
to host this beacon so that it doesn't shut down when other processes
shut down.
"""
global _beacon
if _beacon is None:
_logger.debug("About to start beacon with port %s", port)
try:
_beacon = _Beacon(port)
except (OSError, socket.error) as exc:
if exc.errno == errno.EADDRINUSE:
_logger.warn("Beacon already active on this machine")
#
# _remote_beacon is simply a not-None sentinel value
# to distinguish between the case where we have not
# yet started a beacon and where we have found one
# in another process.
#
_beacon = _remote_beacon
else:
raise
else:
_beacon.start()
def handle(self, *args, **options):
addrport = options['addrport']
if ':' not in addrport:
raise CommandError('Invalid addr:port specified: %s' % addrport)
splitted = addrport.split(':')
try:
splitted[1] = int(splitted[1])
except ValueError:
raise CommandError('Invalid port specified: %s' % splitted[1])
self.stdout.write('Check if toaster can listen on %s' % addrport)
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(tuple(splitted))
except (socket.error, OverflowError) as err:
errors = {
errno.EACCES: 'You don\'t have permission to access port %s' \
% splitted[1],
errno.EADDRINUSE: 'Port %s is already in use' % splitted[1],
errno.EADDRNOTAVAIL: 'IP address can\'t be assigned to',
}
if hasattr(err, 'errno') and err.errno in errors:
errtext = errors[err.errno]
else:
errtext = force_text(err)
raise CommandError(errtext)
self.stdout.write("OK")
def test_rapid_restart(self):
authkey = os.urandom(32)
manager = QueueManager(
address=('localhost', 0), authkey=authkey, serializer=SERIALIZER)
srvr = manager.get_server()
addr = srvr.address
# Close the connection.Listener socket which gets opened as a part
# of manager.get_server(). It's not needed for the test.
srvr.listener.close()
manager.start()
p = self.Process(target=self._putter, args=(manager.address, authkey))
p.daemon = True
p.start()
queue = manager.get_queue()
self.assertEqual(queue.get(), 'hello world')
del queue
manager.shutdown()
manager = QueueManager(
address=addr, authkey=authkey, serializer=SERIALIZER)
try:
manager.start()
except IOError as e:
if e.errno != errno.EADDRINUSE:
raise
# Retry after some time, in case the old socket was lingering
# (sporadic failure on buildbots)
time.sleep(1.0)
manager = QueueManager(
address=addr, authkey=authkey, serializer=SERIALIZER)
manager.shutdown()
#
#
#
def test_handle_stream_closed(self):
self.layer.socks_conn = Mock()
self.layer.socks_conn.send = Mock(side_effect=self.collect_send_event)
socks_request = Request(
REQ_COMMAND["CONNECT"], ADDR_TYPE["IPV4"],
u"1.2.3.4", self.port)
addr_not_support_status = RESP_STATUS["ADDRESS_TYPE_NOT_SUPPORTED"]
network_unreach_status = RESP_STATUS["NETWORK_UNREACHABLE"]
general_fail_status = RESP_STATUS["GENRAL_FAILURE"]
error_cases = [
(errno.ENOEXEC, addr_not_support_status),
(errno.EBADF, addr_not_support_status),
(errno.ETIMEDOUT, network_unreach_status),
(errno.EADDRINUSE, general_fail_status),
(55566, general_fail_status)]
for code, expect_status in error_cases:
self.layer.create_dest_stream = Mock(
side_effect=self.create_raise_exception_function(
StreamClosedError((code, ))))
result_future = self.layer.handle_request_and_create_destination(
socks_request)
with self.assertRaises(DestNotConnectedError):
yield result_future
self.assertIsNotNone(self.event)
self.assertIsInstance(self.event, Response)
self.assertEqual(self.event.status, expect_status)
self.assertEqual(self.event.atyp, ADDR_TYPE["IPV4"])
self.assertEqual(str(self.event.addr), "1.2.3.4")
self.assertEqual(self.event.port, self.port)
def _init_server(self):
# find our Bluetooth address
self.bt_addr = self._find_local_bdaddr()
self.bt_addr_queue.put(None)
# find a free port; PORT_ANY does not seem to work correctly
port_available = False
server_sock = BluetoothSocket(RFCOMM)
for port in range(1, 10):
try:
server_sock.bind((self.bt_addr, port))
port_available = True
break
except Exception as e: # IOError does not seem to catch the right exception
if e[0] == errno.EADDRINUSE:
pass
else:
raise e
if not port_available:
print 'No free bluetooth port found'
return None
server_sock.listen(1)
port = server_sock.getsockname()[1]
advertise_service( server_sock, self.service_desc
, service_id = self.service_uuid
, service_classes = [ self.service_uuid ]
, profiles = [ ]
)
return server_sock
